Java基础学习-面向对象

Day02面向对象

面向过程：实现一个功能，详细处理每一个细节

面写对象：实现一个功能，不关心步骤

三个特征：封装，继承和多态

类：一组相关属性和行为的集合。

属性：成员变量，在方法外，类内

行为：main类中的成员方法，不写static关键字，main中的可以写

类是抽象的，对象是具体的。

类是对象的模板。对象是类的实体。实例化–创建

导包：import 包名称.类名称；

创建格式：类名 对象名 = new 类名（）；

使用成员变量：对象名.成员变量名

使用成员方法：对象名.成员方法名（）；

创建方法：修饰符 类名 方法名（参数类型 参数名） { }

创建对象时，new一个对象，成员方法的地址放入堆中。

类名 对象名1 = new 类名（）；//与对象名不同地址

类名 对象名1 = 对象名；//与对象名同地址

1.使用对象类型作为方法参数：

修饰符 返回值类型 方法名（类名 对象名3）{ 对象名3.方法名0 }。

调用：方法名（对象名1）；栈中{ 对象名3 }传递的是地址值。与对象名1地址一样。

2.使用对象类型作为返回值：也是返回对象的地址

局部变量：方法的内部，没有默认值，**方法的参数是局部变量。**位于栈内存。随着方法进栈而诞生。

成员变量：在方法的外部，写在类当中，整个类通用，有默认值。位于堆内存。随着对象创建而诞生，随着对象被垃圾回收而消失。

方法就是一种封装，关键字private也是一种封装。

封装就是将一些细节信息隐藏起来，对外界不可见。

用private关键字将需要保护的成员变量进行修饰。只能在本类中进行使用，超出本类不能直接访问。只能间接访问进行设置

----setAge（int age）{ this.age = age; } set成员变量名{首字母大写}（）setXxx，不能有返回值类型。参数类型与成员变量进行对应。

----getAge（return age;） 获取私有数据，间接访问。不能有参数。返回值类型与成员变量进行对应。

注意：对于Boolean类型，Getter方法要写成isXxx形式，Setter的setXxx规则不变。

方法的局部变量和类中的成员变量重名，就近原则，优先使用局部变量。

本类访问成员变量：this.成员变量名 通过谁调用，谁就是this

创建方法，使用new就是在调用构造方法

public 类名称（参数类型 参数名称）{ 方法体 }

构造方法的名称与所在类名称完全一样

构造方法没有返回值类型，没有void

构造方法中不能return一个具体的返回值

编译器会设置默认赠送一个构造方法，一但写了至少一个构造方法，默认构造方法则消失。

构造方法也是可以进行重载的。

所有的成员变量都要使用private关键字

为每一个成员变量编写Getter/Setter方法

编写一个无参数的构造方法

编写一个全参数的构造方法

使用Alt + Insert 进行补全Getter/Setter方法 。或者code + Generate

Application Programming Interface 应用程序编程接口

JDK是使用类的说明文档。类名第一个字母大写，方法都是小写。

Scanner，必须有参

实现键盘输入数据，引用类型的一般步骤：导包，创建，使用。

只有Java.lang包下的内容不需要导包。

System.in 从键盘输入。 对象名.nextInt() 获取输入 数字，字符串是next()

new 类名（）.成员变量名 = 赋值；

匿名对象只能使用唯一一次，下次再用不得不再创建新对象。

例如输入：

int num = new Scanner（System.in）.nextInt();

使用匿名对象进行传参：

method ( new Scanner ( System.in ) )；

使用匿名对象进行返回：

return new Scanner( System,in ) ；

import java.util.Random; Random r = new Random(); int num = r.nextInt(3) ; [0,3)

1

2

3

对象名[ ] array = new 对象名[ 3 ]; list.geti 快速生成

存储的是对象的地址。

数组一但创建长度不可改变。ArrayList 可以改变，其实是复制到一个更大的数组。

泛型，装在集合中所有元素，只能为引用类型，不能是基本类型。

ArrayList list = new ArrayList<>(); list.add("XXX")；//添加， boolean success = list("xxx")；//其返回值是否添加成功 list.get(0)//获取当前元素，参数是索引,返回值是对应位置的元素 list.remove(0)//删除元素，参数为索引，返回值是被删除的元素 list.size() // 集合长度，返回元素个数

1

2

3

4

5

6

7

向 集合 Arraylist存储基本类型，使用基本类型的”包装类“。

int – Integer , char – Character , 其他均为首字母大写

自动装箱，基本类型–>包装类型

自动拆箱，包装类型–>基本类型

集合也是可以作为方法的参数的。传递的是地址值，记住泛型格式一致

字符串内容是常量,字符串是可以共享使用，字符串String str ， str保存的是地址值，字符串中 + 号是拼接。

字符串效果相当于是char[ ]字符数组，但底层是byte[ ]字节数组，即都会转为byte进行与字符串对象进行对应。

public String(char[ ] array)//，根据字符数组内容创建 public String(byte[ ] array)， byte[ ] byteArray = {97， 98}； String str = new String(byteArray);

1

2

3

4

5

6

7

直接写上双引号，就是字符串对象。存在字符串常量池（在堆中）中。字符串池的对象是指向byte的地址值。

内容一样的双引号字符串，字符串池的地址会重复使用。

使用new的不在池当中。

对于引用类型来说，==是{地址值}的比较。基本类型，==是值的比较。

字符串对象名.equals( Object obj )，参数可以是任何对象，进行内容比较。

“XXX”.equals( obj )。推荐把常量字符串写在前面，可能会出现NullPointerException，空指针异常。

Obj.equalsIgnoreCase( obj )，不区分大小写的对比。

int length()：字符串长度

String concat(String str)：拼接字符串，并返回一个新的字符串。

char ch = char chatAt (int index)：获取指定索引的单个字符，索引从0开始。

int indexOf(String str)：查找参数字符串第一次出现的索引的位置。

String substring( int index )：截取从参数位置开始到字符串末尾，返回新字符串

String substring( int begin , int end) ：截取中间字符串，[ begin, end )

char[ ] toCharArray()：把字符串拆分为字符数组作为返回值。

char[ ] chars = xx.toCharArray();

byte[ ] getBytes()：获取字符串底层的字节数组

byte[ ] bytes = xx.getBytes();

String replace( CharSequence oldString , CharSequence newString)：将所有出现的老字符串替换为新字符串。 replaceAll所有出现

CharSequence 接口，可以接受字符串数组。

String[ ] split( String regex) ：分割字符串，按照参数规则进行切分，返回字符串数组

String[ ] array1 = xx.split(",");

注意：split参数是正则表达式，使用’’." 应该使用"//."；

直接在类里面进行保存，所有类对象共享一份。不属于对象自己，属于类。在栈里面直接与方法区进行连接。只和类有关，随着类的消失而消失。生命周期最长。

静态变量存储在方法区的静态区中。 实例变量存在于对象所属的堆内存中。

修饰成员变量：只需要赋值一次。多个对象共享同一个对象。例如：计数器，进行每次new时进行自增，++idCount。

修饰成员方法：静态方法属于类，可以使用类名来调用。推荐使用类名称进行调用。对于本类当中的静态方法，类名可以省略。

类名称.静态变量

类名称.静态方法()

注意：

静态方法不能直接访问非静态变量。因为内存中先有静态内容。

静态方法不能写this关键字，谁调用的方法，谁就是当前对象。

静态代码块：执行到本类时，静态代码块唯一执行一次。一次性的对静态成员变量赋值

静态内容优先于非静态。比构造方法先执行。可以有多个静态代码块。

public class 类名称{ static{ //静态代码块内容 } }

1

2

3

4

5

与数组相关的工具类，有大量的静态方法。

static String toString( 数组 )：将参数数组按照默认格式变为字符串。默认格式：[ 元素1，元素2，… ]

static void sort( 数组 )：按照默认升序进行数组排序。字符串：按照字母升序。自定义的类需要有Comparable或者Comparator接口支持

Math()

java.util.Math

static double abs(double num)：获取绝对值，有多种重载

static double ceil(double num)：向上取整

static double floor(double num)：向下取整

static long round(double num)：四舍五入

Math.PI 圆周率（double）

Arrays.asList()可以插入null，而List.of()不可以

继承

继承是多态的前提。主要解决的问题是共性抽取。

父类（超类）—> 子类（派生类）

特点：

子类可以拥有父类的内容，子类还可以进行扩展。

子类可以被当成父类看待。因为在new一个子类是，堆中的子类里面包含一个父类。

public class 父类名称{ } public class 子类名称 extends 父类名称{ }

1

2

3

如果创建子类对象时，成员变量重名：

直接子类对象访问成员变量：等号左边用谁就优先用谁。

间接通过成员方法访问成员变量：优先访问本类当中的。方法属于谁，优先用谁。

成员变量名重名

局部变量：直接写成员变量名

子类成员变量：this.成员变量名

父类成员变量：super.成员变量名

方法重名

创建的对象是谁，就优先用谁。即new 类名（），则用这个类

重写 Override：方法名称一样，参数列表一样。覆写，覆盖。

重载 Overload：方法名称一样，参数列表不一样

创建是子类对象，则使用子类方法。

注解：@Override 写在方法前面，用来检测是不是有效的正确覆盖重写。这个注解是可选的安全检测。

子类方法的返回值必须小于等于父类方法的返回值范围。

修饰符 返回值类型 方法名（参数类型 参数名，…） { return 返回值；}

java.lang.Object 类是所有类的公共最高父类。

子类方法的权限必须大于等于父类的权限修饰符。

修饰符 返回值类型 方法名（参数类型 参数名，…） { return 返回值；}

public > protected > (default) > private

备注： (default) 不是关键字，而是什么都不写，留空。

设计原则：对于已投入使用的类，尽量不要修改。建议定义有个新类，重复使用有共性的内容，并且添加改动的新内容。

先出父类的构造方法，在调用子类构造方法。

子类构造方法有一个隐含的super( ) 调用，无参数的才赠送，有参数的不赠送。

可以通过super关键字来子类构造方法调用父类重载构造方法。

使用 super( 参数值 ) 调用父类重载的构造方法。

XX（int num）-- 重载无参数的XX（）。

注意：super的父类构造，必须是子类构造方法中的第一个（行），只能调用一次。

用法：

子类的成员方法中访问父类的成员变量。

子类的成员方法中访问父类的成员方法。

子类的构造方法中访问父类的构造方法。

this关键字访问本类内容

在本类的成员方法中，访问本类的成员变量。

在本类的成员方法中，访问本类的另一个成员方法。如果覆写是可以强调是本类的方法。

在本类的构造方法中，访问本类的另一个构造方法。this调用也必须是构造方法的第一个语句，一个构造方法里唯一一个。且当前构造方法调用另一个构造方法之后，不能被其他构造方法所调用访问。

super和this的构造调用不能同时。

super_class在子类的方法区中指向父类方法区。

Java是单继承的，一个类的直接父类只能有唯一一个。

Java可以多级继承。

一个父类可以拥有很多个子类。

如果父类方法不确定如何进行方法实现。

抽象方法：加上abstract关键字，去掉大括号，直接分号结束

抽象类：抽象方法所在的类。必须是抽象类

抽象方法和抽象类：

不能直接创建new抽象类

必须用一个子类来继承抽象父类。

子类必须覆盖重写父类方法中的所有抽象方法，子类去掉抽象方法的abstract关键字，补上大括号。否则子类也是抽象类。但后面的子类总要覆写。

创建子类对象进行使用。

注意：本文符号有中文符号，请不要直接复制

Java 面向对象编程

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。