1.关键字
2.方法,代码块优先级
3.继承.
4.方法重写.
5.this 和 super .
6.多态.
7.抽象类
8.成员变量和局部变量的区别
9.冒泡排序
10.接口和抽象类的区别
11.与 abstract 冲突的关键字
1.关键字
1)static
特点:
a.static 随着类的加载而加载;
b.优先于对象存在,不能于this共存;
c.能够被多个对象共用;
d.它的特殊访问方式:通过类名.变量名---->类变量(变量被static修饰的)
通过类名.方法名()--->类方法(方法被static修饰)
注意事项:
静态方法,只能访问静态变量,只能调用静态方法.
2)final:是状态修饰符,最终的,无法更改的.
特点:
a.可以修饰类,该类不能被继承;
b.可以修饰成员方法,该方法不能被重写;
c.可以修饰变量,此时变量是一个常量;
定义常量格式:
public static final 数据类型 变量名 = 初始化;
2.方法,代码块优先级
静态代码块 > 构造代码块 > 构造方法
静态只执行一次.
3.继承.
继承: 将多个类的共性内容抽取到一个独立的类中,让这多个类和独立的类之间产生一种关系.
1)格式:
class Fu{
//将一些功能抽取到父类中
}
class Zi extends Fu{
}
2)继承的好处:
a.可以提高代码复用性
b.提高的代码的维护下
c.类与类之间产生的关系:是多态的前提条件!
3)继承的特点:
a.类与类之间的关系,只支持单继承,不支持多继承!
b.可以支持多层继承!
4)继承中,子类与父类的成员变量名称一致的情况访问方法:
a.先在子类的局部位置中找,是否存在这个变量名称,如果存在,就使用;
b.如果不存在,那么就在子类的成员位置中找是否存在,如果存在,就使用;
c.如果不存在,那么在父类的成员位置中找是否存在,如果存在,就使用;
d.如果不存在,就会报错.
5)继承中构造方法的访问,子类如何访问父类的构造方法:
a.子类的所有的构造方法的第一句话默认的:super();
b.子类的所有构造方法间接访问父类的无参构造方法:
6)那么如果父类中没有无参构造方法解决方法:
a.可以通过手动给出无参构造方法;
b.子类的所有构造方法的第一句话: 通过super(xxx):访问父类的有参构造方法;
c.在子类的有参构造方法中的第一句话:this():来先访问本类的无参构造方法,然后再访问本类无参构造方法,super(xxx):访问父类的有参构造方法,让父类进行初始化.
例:
class Fu{
public Fu(int i){
System.out.println("class Fu(int i)") ;
}
}
class Zi extends Fu{
public Zi(){
super(10) ;//本类的无参构造方法直接先访问父类的有参构造方法
System.out.println("class Zi()") ;
}
public Zi(String str){
this() ; //先访问本类的无参构造方法
System.out.println("class Zi(String str)") ;
}
}
4.方法重写.
方法重写: 在继承关系中,子类出现了和父类一样的方法,这个子类将父类的功能覆盖,创建子类具体对象.
目的: 为了沿用父类的功能,并且还需要使用子类的功能.
5.this 和 super .
this:代表当前类对象的地址值引用
super:代表的父类的空间标识(代表父类对象的地址值引用)
访问成员变量,成员方法,构造方法
成员变量:
this.变量名; 它的访问的是本类的成员变量
super.变量名; 访问父类的成员变量
成员方法:
this.方法名() ;访问本类的成员方法
super.方法名() ;访问父类的成员方法
构造方法:
this() ;访问的是本类的无参构造方法
super() ;访问的是父类的无参构造方法
this(具体值) ;访问的是本类的有参构造方法
super(具体值);访问的是父类的有参构造方法
6.多态.
多态: 一个事物在不同时刻体现的不同形态.
1)前提条件:
a.必须有继承关系
b.必须存在方法重写
c.必须父类引用指向子类对象
Fu f = new Zi() ;
2)员访问特点:
a.成员变量:编译看左,运行看左
b.成员方法:(非静态):编译看左,运行看右,(存在方法重写)
c.静态的方法:不算方法重写,跟类相关(编译看左,运行看左)
d.构造方法:分层初始化(先父类,在子类)
3)多态的转型:
a.向上转型: 父类引用指向子类对象
Fu fu = new Zi();
b.向下转型: 父类强转为子类引用
Zi zi = (Zi)fu;
多态的弊端: 不能访问子类的特有功能,故许向下转型.
4)多态的弊端:
a. ArrayIndexOutOfBoundsException:数组角标越界异常
检查继承关系是否有问题
b. IndexOutOfBoundsException:角标越界异常
出现不存在的角标
c. StringIndexOutOfBoundsException:字符串角标越界异常
检查继承关系是否有问题
d. IndexOutOfBoundsException:角标越界异常
e. NullPointerException:空指针异常,是在描述当某一个对象通过一些功能被获取的时候可能 为null,这个时候还使用当前对象调用方法,就会通过jvm抛出这异常!
解决方案:
针对某个对象进行非空判断
7.抽象类
抽象类:现实事物中,某个事物比较概括性的,描述为抽象事物.
特点:
a.有抽象方法的类一定是抽象类;
b.抽象类不一定都是抽象方法;
c.抽象类不能实例化;
d.抽象类通过子类实例化,抽象类多态.`
格式:
抽象方法: 权限修饰符 abstract 返回值类型 方法名(形参列表)
抽象类格式: abstract class 类名{}
抽象类的宗旨: 强制子类必须完成的事情(将父类中的所有抽象方法必须重写)
例:
abstract class Animal{
public abstract void eat();
public void show(){
System.out.println("show animal...");
}
public abstract void slepp() ;
public Animal(){ //Animal抽象类=---- 不能new Animal()
System.out.println("Animal的无参构造方法");
}
}
class Cat extends Animal{
public Cat(){
System.out.println("Cat的无参构造方法");
}
@Override
public void eat() {
System.out.println("猫吃鱼...");//重写
}
@Override
public void slepp() {
System.out.println("猫趴着睡觉...");//重写
}
//特有功能
public void playGame(){
System.out.println("猫玩毛线");
}
}
class Dog extends Animal{
@Override
public void eat() {
System.out.println("狗吃骨头");//重写
}
@Override
public void slepp() {
System.out.println("狗侧着睡觉...");//重写
}
//特有功能
public void catchRabit(){
System.out.println("狗可以抓兔子");
}
}
//测试类
public class AbstractDemo {
public static void main(String[] args) {
//创建动物类对象
// Animal a = new Animal() ;//抽象类不能创建对象
Animal a = new Cat() ;//抽象类多态
a.eat();
a.slepp();
// a.playGame() ; 父类没有这个功能
//向下转型
Cat c = (Cat)a ;
c.playGame();
System.out.println("-------------------------");
a = new Dog() ;
a.eat();
a.slepp();
Dog d = (Dog) a;
d.catchRabit();
}
}
8.成员变量和局部变量的区别
1)书写位置不同:
成员变量在类中方法外;
局部变量在方法定义或声明上;
2)存储位置不同:
成员变量在堆内存;
局部变量在栈内存;
3)初始化不同:
成员变量不需要手动初始化,系统自动初始化;
局部变量在使用钱必须初始化;
4)生命周期不同:
成员变量随着对象的创建而存在;
局部变量随着方法的调用而出现,随着方法结束而消失.
9.冒泡排序
核心思想: 两两比较,较大的值往后放,第一轮比较完,最大值出现在最大索引出.
代码体现:
for(int x = 0 ; x < arr.length-1; x ++){
for(int y = x + 1; y< arr.length ; y ++){
if(arr[y] < arr[x]){
int temp = arr[x] ;
arr[x] = arr[y] ;
arr[y] = temp ;
}
}
}
10.接口和抽象类的区别
1)成员的区别
抽象类:
a.成员变量:既可以是变量,也可以是常量;
b.成员方法: 可以存在抽象方法(带abstract关键字),也可以有非抽象方法;
c.构造方法: 存在无参和有参构造;
接口:
a.成员变量:只能是常量,存在默认的修饰符 public static final 修饰;
b.成员方法:只能是抽象方法,存在默认修饰符public abstract;
c.构造方法: 不存在.
2)关系的区别
类与类: 继承关系,只支持单继承,不支持多继承,可以多层继承;
类与接口: 实现关系,类继承类的时候可以实现多个接口,逗号隔开;
接口与接口: 继承关系,支持单继承,多继承和多层继承.
3)设计理念
抽象类: 强制子类必须完成的事情,存在继承关系,是"is a"的关系;
接口: 体现某个事物的额外功能,能实现接口就能继承该功能,是"like a"的关系.
11.与 abstract 冲突的关键字
final , static , private
930
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
