-
带static的方法用类名. 去调用,不带static的方法 先new 对象,然后用引用去调(实例方法)
-
封装
(1)怎么封装?
1.属性私有化(使用private关键字进行修饰)
2.对外提供简单的操作入口
(2)封装不能写static
带有 static 关键字的方法是静态方法,不需要创建对象，直接通过“类”来调用。对于没有 static 关键字的方法被称为实例方法，这些
方法执行时要求必须先创建对象，然后通过“引用”的方式来调用。而对于封装来说，setter 和 getter 方法都是访问对象内部的属性，
所以 setter 和 getter 方法在定义时不能添加 static 关键字 -
继承 extends关键字
(1) 语法: public class 类A extends 类B { //子承父业}
• 类A: 叫子类, 或者派生类.类B: 叫父类, 基类, 或者超类. 我们一般会念做: 子类和父类.
(2) 继承可以继承成员变量和成员方法.构造方法不能被继承,私有的不能被继承,
被private 修饰的成员不能直接继承,要用set 和 get 方法去访问
- (3) java的类和类之间只支持单继承,但是可以多层继承
java中的类没有显示继承任何类时，缺省继承Object类.Object类是所有类的超类/基类/祖宗类
(3) 好处和弊端:
好处:1. 提高了代码的复用性 2. 提高了代码的可维护性 3. 让类与类之间产生关系, 是多态的前提
有了继承，才有了方法的覆盖和多态机制
弊端:让类与类之间产生了关系, 也就让类的耦合性增强了
开发原则: 高内聚, 低耦合. 内聚: 指的是类自己独立完成某些事情的能力(方法功能要单一) 耦合: 指的是类与类之间的关系
** (4) super 关键字 (存储的是地址) super不能使用在静态方法中。 -
(5) super.什么时候不能省略呢this 关键字使用本类,super使用的是父类 super.方法名 用来访问父类的成员方法 在构造方法的第一行,默认添加一行super();调用父类的无参构造. (里面加参数就调用有参) 调用子类的构造方法时: 1. 先执行子类的构造方法 2. 在子类的构造方法中第一行有个super 3. 通过super()调用父类的构造方法 4. 父类的构造方法执行结束后,在执行子类的构造方法 子类要用父类中的成员,是使用父类已经初始化之后的,所以会先调用父类的无参构造方法 -
父类和子类中有同名属性，或者说有同样的方法，想在子类中访问父类的，super. 不能省略。 super的使用： super.属性名 【访问父类的属性】 super.方法名(实参) 【访问父类的方法】 super(实参) 【调用父类的构造方法】 super 不是引用,也把保存内存地址,也不指向任何对象 (不能直接使用super)
** (6) this 关键字 (保存着地址值) this 变量是一个引用
this代表本类当前对象的引用, 大白话翻译: 谁调用, this就代表谁
用来解决局部变量和成员变量重名问题的
this 只能存在在实例方法中,谁调用该方法,this就代表谁. 指向的是当前对象
this.方法名称 用来访问本类的成员方法
this(); 通过当前类的方法去访问另外一个本类的构造方法. this()中可以有参数的 如果有参数 就是调用指定的有参构造
this()和super()不能同时存在在一个构造方法内 (都写在构造方法第一行)
(7)调用成员方法时, 也遵循就近原则, 本类中有, 就直接调用, 本类中没有, 就去父类中查找, 有就使用, 没有就报错.
-
方法重写与方法覆盖:
(1).子类重写父类方法时, 方法声明上要用@Override注解来修饰(可以不写).
父类中私有的方法不能被重写.
子类重写父类方法时, 访问权限不能更低.
(2) 方法覆盖就是将继承过来的方法覆盖掉,继承过来的方法没了
什么条件满足的时候构成方法覆盖？
第一：有继承关系的两个类
第二：具有相同方法名、返回值类型、形式参数列表
第三：访问权限不能更低。
第四：抛出异常不能更多。
总结:私有不能覆盖。静态不谈覆盖。
(3) 方法重载和方法覆盖有什么区别
方法重载发生在同一个类当中。
方法覆盖是发生在具有继承关系的父子类之间。
方法重载是一个类中，方法名相同，参数列表不同。
方法覆盖是具有继承关系的父子类，并且重写之后的方法必须和之前的方法一致：
方法名一致、参数列表一致、返回值类型一致。
(4)toString()方法存在的作用就是：将java对象转换成字符串形式。
大多数的java类toString()方法都是需要覆盖的。因为Object类中提供的toString()
方法输出的是一个java对象的内存地址。 -
多态
(1) Animal an = new Cat(); (前面是父类,后面是子类)
成员属性:编译看左边,运行看左边
成员方法: 编译看左边, 运行看右边.
编译期叫做静态绑定。运行期叫做动态绑定。
(3) 好处和弊端:
好处:提高了程序的扩展性.
弊端:父类引用不能访问子类的特有功能. 通过向下转型来解决这个问题.
(4) 向上转型:格式 父类型 对象名 = new 子类型(); 子—>父 又被称为自动类型转换：Animal a = new Cat();
(5) 向下转型: 格式 子类型 对象名 = (子类型)父类引用; 父—>子 又被称为强制类型转换：Cat c = (Cat)a;
需要添加强制类型转换符。
(6) 什么时候需要向下转型？
需要调用或者执行子类对象中特有的方法。必须进行向下转型，才可以调用。
向下转型有风险吗？
容易出现ClassCastException（类型转换异常）
-
怎么避免这个风险？(引用 instanceof 类型) 运算结果只能是true/false 例如: c instanceof cat 为ture表示 c引用指向的堆内存中的java对象是一个cat 反之则不是(可以用if来用) instanceof运算符，可以在程序运行阶段动态的判断某个引用指向的对象是否为某一种类型。 养成好习惯，向下转型之前一定要使用instanceof运算符进行判断。
- static 关键字:静态的 (属性共享 静态访问静态 )
成员变量为(实例变量,静态变量)
(1) static修饰的统一都是静态的，都是类相关的，不需要new对象。直接采用“类名.”访问。(也可以用引用. 访问)
(2) 当一个属性是类级别的属性，所有对象的这个属性的值是一样的，建议定义为静态变量。
(3) 静态变量是在类加载时初始化,不需要new对象 ,静态变量的空间就开出来了.
*** 静态变量存储在方法区 局部变量(所有的方法)在栈中 ,实例变量在堆中
- (4)使用static 关键字可以定义静态代码块 语法: static { java语句; java语句 }
1. 静态代码块在类加载中执行,并且只执行一次,而且在main方法之前执行,不管在写在main方法前还是后,一般按照自上而下执行
2. 静态代码块不是很常用,有需要才用,可以用来纪录类加载的日志,初始化操作等等
(5) 实例语句块 语法{ java语句;java语句;java语句;}
只要是构造方法执行,必然在构造方法执行之前,自动执行"实例语句块"的代码. 叫做对象构建时机. - (6) static 修饰方法 只能访问静态方法和静态变量
*35. 空指针异常只有在"空引用"访问实例变量时会出现,访问静态变量不会出现空指针异常. 如果方法体中直接访问了实例变量就要定义为
实例方法,工具类中的方法一般都是静态方法(静态方法就一个特点,不需要new对象,直接用类名. 进行访问 )
-
system.out.println()
system 是一个类名
out是一个静态变量,
system.out是返回一个对象
system.out.println() 相当于 对象.println() 调用打印这个方法
注意: 所用system.out.println(引用)方法执行时,如果输出引用的话,自动调用引用的toString()方法. -
final 关键字 (final修饰的变量只能赋一次值)
(1) final修饰的类无法继承。
(2) final修饰的方法无法覆盖和重写。
(3) final修饰的变量只能赋一次值。
(4) final修饰的引用一旦指向某个对象，则不能再重新指向其它对象，但该引用指向的对象内部的数据是可以修改的。
(5) final修饰的实例变量必须手动初始化，不能采用系统默认值。
(6) final修饰的实例变量一般和 static 联合使用，称为常量。(常量名建议全部大写,单词与单词之间用"_"隔开)
38 抽象方法
(1) 特点:没有方法体,以;结尾,用abstract 修饰 public abstract void doSome(); 抽象类不一定有抽象方法,但抽象方法一定在抽象类中
包含abstract 修饰的方法的类也得是抽象的(称为抽象类)
普通类继承抽象类之后 必须重写抽象方法.抽象类继承抽象类时候 可以不用重写抽象方法.
(2) 抽象类不能创建对象 还得写构造方法 用来初始化父类成员
(3) final和abstract不能联合使用，这两个关键字是对立的
- 接口 用 interface 关键字修饰 语法: [修饰符列表] interface 接口名{}
(1) 类和接口之间是实现关系, 用 implements 关键字表示.
(2) 在接口中只能有常量(成员属性都是常量 用 public static final 修饰 可以不写,系统默认加上 )
成员方法都是抽象方法 (在接口中的方法默认是抽象方法,写 public abstract 修饰)
** [在jdk1.8的时候接口中加入了两个新的成员: 静态方法( 用static修饰 ), 默认方法(必须用default修饰).]
调用静态方法把静态方法放方法里面;
(3) 接口不能实例化. 可以通过多态的方式, 创建其子类对象, 来完成接口的实例化. 这也叫: 接口多态
(4) 接口与接口可以多继承
类与接口之间是实现关系, 可以单实现, 也可以多实现. 还可以在继承一个类的同时实现多个接口
- (5) 一个完整的类声明的语法格式: public class MyClass extends Superclass implements MyInterface1,MyInterface2{}
接口是完全抽象的
接口中没有构造方法，无法实例化 -
接口中只允许出现常量和抽象方法 接口中常量的public static final可以省略 接口中抽象方法的public abstract可以省略 接口中所有的数据都是public修饰的 -
(6) 接口在开发中的作用接口和接口之间可以多继承 实现implements也可以看做是一种变相的继承extends 一个非抽象的类实现接口必须将接口中所有的方法加以实现
面向抽象编程，面向接口编程，不要面向具体。接口联合多态可以降低程序的耦合度，提高程序的扩展力。遵循OCP开发原则。
-
抽象类和接口有什么区别
(1) 抽象类是半抽象的。接口是完全抽象的。
(2) 抽象类中有构造方法。接口中没有构造方法。
(3) 接口和接口之间支持多继承。类和类之间只能单继承。
(4) 一个类可以同时实现多个接口。一个抽象类只能继承一个类（单继承）。
(5)接口中只允许出现常量和抽象方法。
(6) 以后接口使用的比抽象类多。一般抽象类使用的还是少。接口一般都是对“行为”的抽象。 -
访问权限 (权限修饰符)
(1) private: 强调的是给自己类使用
(2) 默认: 强调的是给同包下的类使用
(3) protected: 强调的是给子类使用
(4) public: 强调的是给大家使用 -
类和类之间的关系
(1) 泛化关系
(2) 实现关系
(3) 关联关系
(4) 聚合关系
(5) 组合关系
(6) 依赖关系
(7) is a（继承）、has a（关联）、like a（实现）
is a：
Cat is a Animal（猫是一个动物） 凡是能够满足is a的表示“继承关系”
A extends B
has a：
I has a Pen（我有一支笔）凡是能够满足has a关系的表示“关联关系”
关联关系通常以“属性”的形式存在。
A{B b;}
like a:
Cooker like a FoodMenu（厨师像一个菜单一样） 凡是能够满足like a关系的表示“实现关系”
实现关系通常是：类实现接口。
A implements B
**43. String 常用类 toString方法和equals方法要记得重写(要养成这种习惯)
(1) 字符串一旦被赋值 其值不能发生变化
(2) 常用方法
1.endsWith：判断字符串是否以指定的后缀结束 返回布尔类型
2. startsWith，判断字符串是否以指定的前缀开始
3. equals，字符串相等比较，不忽略大小写
4. equalsIgnoreCase，字符串相等比较，忽略大小写
-
- indexOf，取得指定字符在字符串的位置(第一次出现)
- lastIndexOf，返回最后一次字符串出现的位置
- length，取得字符串的长度
- replaceAll，替换字符串中指定的内容
- split，根据指定的表达式拆分字符串
-
- substring，截取字符串
-
- trim 去除字符串前后空格
** 12. valueOf，将其他类型转换成字符串
- trim 去除字符串前后空格
- 13.compareTo 按字典顺序比较2个字符串大小 大于返回1,小于返回-1,等于返回0
14.contains 判断前面的字符串是否包含后面的字符串 返回布尔类型
15.getBytes 将字符串对象转换成字节数组
16.isEmpty 判断某个字符串是否为"空字符串"
17.toCharArray 将一段字符串转为char类型的数组
18.toLowerCase 将字符串的字符转成小写
19.String toUpperCase() 将字符串的字符转成大写
1)String 变量名 = new String(char[] chs,int index,int count); index 起始索引值 count 代表的个数(长度) 字符串类型
2)String 变量名 = new String(byte[] bys,int index,int count); index 起始索引值 count 代表的个数(长度) 数字类型
char charAt(int index) 截取字符串 从输入的index个开始 返回的是char类型
boolean contains(CharSequence s)
boolean endsWith(String suffix)
boolean equals(Object anObject)
boolean equalsIgnoreCase(String anotherString)
int indexOf(String str)
int lastIndexOf(String str)
String replaceAll(String regex, String replacement)
String[] split(String regex)
boolean startsWith(String prefix)
String substring(int beginIndex)
String substring(int beginIndex, int endIndex)
String toString()
String valueOf(xx) 返回xx参数的字符串表现形式
concat 字符串拼接 返回值是他自己,可以接着并(链式方法) 使用对象. 的方法调用
(3) 存储的位置
String str = “abc” 值存储在字符串常量池
String str = new String(“abc”); 存储在堆内存中
两个相同字面值字符串比较 地址值是一样的 两个new出来的字符串 哪怕内容一样 地址值也是不一样的
(4) new String(“abc”);其实是产生了两个对象 1.“abc” 2.new String();
(5)遍历字符串
length() 获取字符串的长度
char charAt(int index) 根据索引获取字符串中的字符
char[] toCharArray() 将一段字符串转为char类型的数组
(6)比较字符串的内容是否相同
boolean equals 区分大小写
boolean equalsIgnoreCase 不区分大小写
*** (7) 重要方法 toString()方法 equals()方法 finalize()方法
1) toString()方法
以后所有类的toString()方法是需要重写的。重写规则，越简单越明了就好。
System.out.println(引用); 这里会自动调用“引用”的toString()方法。
String类是SUN写的，toString方法已经重写了。
2) equals()方法
以后所有类的equals方法也需要重写，因为Object中的equals方法比较的是两个对象的内存地址，我们应该比较内容，所以需要重写。
重写规则：自己定，主要看是什么和什么相等时表示两个对象相等。
基本数据类型比较实用：== 对象和对象比较：调用equals方法
String类是SUN编写的，String类的equals方法重写了。判断两个字符串是否相等，不要使用==，要调用字符串对象的equals方法。
注意：重写equals方法的时候要彻底。
3) finalize()方法 protected void finalize() throws Throwable { } 垃圾销毁时机
如果希望在对象销毁时机执行一段代码,这段代码就要写到finalize()方法中,finalize()方法只需要重写,重写完会有gc(垃圾回收器)来调用
使对象=null 就可以使对象变成垃圾
提示:java中垃圾回收器不是轻易启动,垃圾太少或时机没到 System.gc(); 建议启动垃圾回收器
4) hasecode()方法 返回的是哈希码 集合中使用多点
实际上就是一个java对象的内存地址,经过哈希算法得出的一个值.他的执行结果可以等同看做一个java对象的内存地址
5)clone方法 有深克隆与浅克隆
-
StringBuilder 就是一个容器 (大大的提高我们拼接字符串的效率)
(1) StringBuilder append(万物皆可) 返回值就是他自己本身 作用:拼接字符串
(2) StringBuilder reverse() 返回值就是他自己本身 作用:内容反转
(3) String toString(); 将StringBuilder中内容以字符串的形式返回 -
内部类 定义在类的内部 (使用内部类代码可读性差)
(1) 实例内部类 类似于实例变量 没有 static的
(2) 静态内部类 类似于静态变量
(3) 局部内部类 类似于局部变量 前面有static 的
匿名内部类 (局部内部类的一种) 因为一个类没用名字,没有办法多次使用 (用来装逼) -
数组
(1) 数组的优点和缺点
第一：空间存储上，内存地址是连续的。
第二：每个元素占用的空间大小相同。
第三：知道首元素的内存地址。
第四：通过下标可以计算出偏移量。
通过一个数学表达式，就可以快速计算出某个下标位置上元素的内存地址，
直接通过内存地址定位，效率非常高。
优点：检索效率高。
缺点：随机增删效率较低，数组无法存储大数据量。
注意：数组最后一个元素的增删效率不受影响
(2) main方法上“String[] args”参数的使用（一般都是有界面的，用户可以在界面上输入用户名和密码等参数信息。）
例如dos命令运行程序: java 类名 adc def xyz 这个时候jvm会自动将"abc def xyz "通过空格的方式进行分离,分离后,自动放到"String[] args"数组里
在idea里面的运行界面的edit configurations里面的Application的 program arguments里输入
(3) 数组扩容
先新建一个大数组,把小数组中的数组一个一个拷贝到大数组中,然后把小数组垃圾回收
System.arraycopy(5个参数); 使用System里面的arraycopy()方法,里面是5个参数;静态方法
(4) 二维数组
二维数组其实是一个特殊的一维数组,特殊在这个一维数组当中的每一个元素是一个一维数组
(5) For-Each 循环
JDK 1.5 引进了一种新的循环类型，被称为 For-Each 循环或者加强型循环，它能在不使用下标的情况下遍历数组。
语法格式如下：for(type element: array){System.out.println(element);}
(6)数组可以作为方法的返回值和方法的参数列表 作为参数列表时,需要你new的对象为类型,返回值也是一样
(7)数组里面可以存储地址
String id = sc.nextLine();
String username = sc.nextLine();
String gender = sc.nextLine();
String height = sc.nextLine();
String age = sc.nextLine();
stus[i] = stu;
object[] 是一个万能口袋,什么都能放,可以放任何引用数据类型
"abcd"是一个字符串对象,有优待,可以不要new
扫一扫
1410
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
