一,需要掌握:

1,会创建类和对象
2.面向对象的三大特征:封装,继承,多态.
3.掌握抽象类和接口的使用
4.掌握程序中的异常处理
5.会使用面向对象思想进行编程

二.开发方法

1.结构化开发(基于c语言)

面向功能划分软件结构
自顶而下
最小的子系统是方法
制约了软件的可维护性和可扩展性

2.面向对象开发

把软件系统看成各种对象的集合
系统结构较稳定
子系统相对独立
软件可重用性,可维护性和可扩展性强

三.类与对象

对象:用来描述客观事物的一个实体,由一组属性和方法构成
类:具有相同属性和方法的一组对象的集合
类是对象的抽象,对象是类的具体

public class person {
    //属性(特征):成员变量
    public String name;
    public int age;
    public char sex;
    
    //方法(行为):成员方法
    public String showInfo() {
        String info = "我叫:"+name+";"+age+"岁;性别"+sex;
        return info;    
    }
}

public class TestPerson {
    public static void main(String[] args) {
        //创建对象:   类名   对象名 = new  类名();
        person p1 = new person();
        //使用对象的属性和方法:对象名.属性     对象名.方法()
        p1.name = "jack";
        p1.age = 18;
        p1.sex = '男';
        
        String s1 = p1.showInfo();
        System.out.println(s1);
        
        
        person p2 = new person();
        p2.name = "rose";
        p2.age = 16;
        p2.sex = '女';
        
        String s2 = p2.showInfo();
        System.out.println(s2); 
    }
}

注意

方法定义处,参数叫做形式参数,也叫形参(主要约束参数的类型的)
形参名字可以随便取,但要符合驼峰命名规则,同时要有意义
方法调用处,参数叫做实际参数,也叫实参
实参名字可以随便取,但要符合驼峰命名规则,同时要有意义
实参和形参的类型必须一致,名字可以一致,也可以不一致
方法有没有返回值和方法有没有参数,没有任何关系
方法参数可以有一个,也可以有多个,多个参数之间用逗号隔开
形参和实参数量一定要一致,数据类型一定要一致

四.构造方法与方法重载

当参数传递为基本数据类型时,参数变化不保留,基本数据类型参数传值
当参数传递为引用数据类型时,参数变化保留,引用数据类型参数传址
方法重载:
同一个类中
方法名相同
参数个数或类型不同
与返回值,访问修饰符无关
构造方法:
(1)该方法缺少返回值
(2)该方法名字必须和类名一样
每个类都有一个默认无参构造方法
但是,一旦手工添加了带参构造方法,那么系统默认的无参构造方法就会被覆盖掉,如果想使用,就必须显示的写出来

public class Student {
    String name;
    int score;
    //一个类中允许出现多个同名但不同参数的方法,这种方法叫做重载
    
    //构造方法
    //(1)该方法缺少返回值  (2)该方法名字必须和类名一样
    //每个类都有一个默认无参构造方法
    //但是,一旦手工添加了带参构造方法,那么系统默认的无参构造方法就会被覆盖掉,如果想使用,就必须显示的写出来

    //方法重载
    public Student() {
        
    }
    
    public Student(String name,int score) {
        this.name = name;
        this.score = score;
    }
    public void showInfo() {
        System.out.println(name+"的成绩是"+score);
    }

}

public class ModifyScore {
    public void modifyScore(Student[] stus) {
        for(int i=0; i<stus.length;i++) {
            if(stus[i].score<60) {
                stus[i].score+=2;
            }
        }
    }
    public void showInfo(Student[] stus) {
        for(Student stu:stus) {
            stu.showInfo();
        }
    }

    public static void main(String[] args) {
        // TODO 自动生成的方法存根
        ModifyScore ms = new ModifyScore();
        Student[] stus = new Student[3];
        
        /*Student s1 = new Student();
        s1.name = "jack";
        s1.score = 58;*/
        
        Student s1 = new Student("jack",58);
        
        /*Student s2 = new Student();
        s2.name = "rose";
        s2.score = 98;*/
        
        Student s2 = new Student("rose",98);
        
        Student s3 = new Student();
        s3.name = "mandy";
        s3.score = 68;
        
        stus[0] = s1;
        stus[1] = s2;
        stus[2] = s3;
        
        ms.modifyScore(stus);
        ms.showInfo(stus);
    }
}

五.封装

1.成员变量与局部变量的区别:
作用域不同:
局部变量的作用域仅限于定义它的方法
成员变量的作用域在整个类内部都是可见的
初始值不同:
Java会给成员变量一个初始值
Java不会给局部变量赋予初始值
注意:
在同一个方法中,不允许有同名局部变量
在不同方法中,可以有同名局部变量
在同一个类中,成员变量和局部变量同名时,局部变量具有更高的优先级

面向对象三大特征之一 ------封装
2.封装的概念:
将类的某些信息隐藏在类内部,不允许外部程序直接访问,而是通过该类提供的方法来实现对隐藏信息的操作和访问
封装的两个大致原则:
把尽可能多的东西藏起来,对外提供便捷的接口
把所有的属性藏起来

3.封装:
1.先将属性私有化
2.为private的属性创建共有的setter/getter方法
3.在getter/setter方法中加入属性控制语句

4.封装的好处:
1.便于使用者正确使用系统,防止错误修改属性
2.有助于系统之间的松耦合,提高系统的独立性
3.提高软件的可重用性
4.降低了构建大型系统的风险

六.继承

1.类的访问修饰
public修饰符:共有访问级别
默认修饰符:包级私有访问级别

image.png

2.static变量
1.类的成员变量包括
类变量(静态变量):
被static修饰的变量
在内存中只有一个拷贝
类内部,可在任何方法内直接访问静态变量
其他类中,可以直接通过类名访问
实例变量:
没有被static修饰的变量
每创建一个实例,就会为实例变量分配一次内存,实例变量可以在内存中有多个拷贝,互不影响
2.static变量的作用:
(1)能被类的所有实例共享,可作为实例之间进行交流的共享数据
(2)如果类的所有实例都包含一个相同的常量属性,可把这个属性定义为静态常量类型,从而节省内存空间
3.static方法:
静态方法:可直接通过类名访问
静态方法中不能使用this和super
不能直接访问所属类的实例变量和实例方法
可直接访问类的静态变量和静态方法
实例方法:通过实例访问
可直接访问所属类的静态变量,静态方法,实例变量和实例方法
静态方法必须被实现 main()就是最常用的静态方法

//模拟实现选民投票过程:一群选民进行投票,每个选民只允许投一次,   并且当投票总数达到100时,停止投票
public class Voter {
    //投票总数,所有选民都会改变的同一个数据  static
    public static int count;
    //100,最大投票数,适用于全部的所有选民,static final
    public static final int MAX_COUNT = 100;
    
    private String name;
    //带参构造方法
    public Voter(String name) {
        this.name = name;
    }

    public String getName() {
        return this.name;
    }

    public void setName(String name) {
        this.name = name;
    }
    public void voteFor() {
        
        if(count == MAX_COUNT) {
            System.out.println("投票结束");
            return;
        }else {
            count++;
        }
        System.out.println(this.name+",感谢您的投票!");
    }
    public static void printResult() {
        System.out.println("选民总数是:"+count);
    }
}

public class TestVoter {

    public static void main(String[] args) {
        // TODO 自动生成的方法存根
        Voter lisa = new Voter("lisa");
        lisa.voteFor();
        Voter.printResult();
        for(int i = 1;i <=99;i++) {
            Voter v = new Voter("v"+i);
            v.voteFor();
        }
        Voter.printResult();
        Voter rose = new Voter("rose");
        rose.voteFor();
        Voter.printResult();
    }
}

方法重写
1.子类继承父类的什么?
继承public和protected 修饰的属性和方法,不管子类和父类是否在同一个包中
继承默认权限修饰符修饰的属性和方法,子类和父类必须在同一个包中
2.不能被继承的父类成员
private成员
子类与父类不在同包,使用默认访问权限的成员
构造方法
3.子类访问父类成员
访问父类构造方法
super();
super(name);
访问父类属性
super.name;
访问父类方法
super.print();
注意:
(1)使用super关键字,super代表父类对象
(2)super只能出现在子类的方法和构造方法中
(3)super调用构造方法时,只能是第一句
(4)super不能访问父类的private成员
4.继承条件下的构造方法
继承条件下构造方法的调用规则
子类构造方法没有通过super显示调用父类的有参构造方法,系统默认调用父类的无参构造方法
子类构造方法通过super显示调用父类的有参构造方法,执行相应构造方法,而不执行父类无参构造方法
5.方法重写规则:
方法名相同
参数列表相同
返回值类型相同或者是其子类
访问权限不能严于父类
父类的静态方法不能被子类覆盖为非静态方法,父类的非静态方法也不能被子类覆盖为静态方法
子类可以定义与父类同名的静态方法,以便在子类中隐藏父类的静态方法(注:静态方法中无法使用super,通过类名调用)
父类的私有方法不能被子类覆盖
不能抛出比父类方法更多的异常
6.方法重写vs方法重载

image.png

Object类
Object类是所有类的直接或间接父类
equals()方法
Object类的equals()方法
-比较两个对象是否是同一个对象,是则返回true
--操作符==
简单数据类型,直接比较值.如1==2
引用类型,比较两者是否为同一对象
1.单根继承
Java只支持单根继承
一个类只能有一个直接父类
一个类可以有多个间接父类
super和this

image.png

七.多态

1.instanceof用于判断一个引用类型所引用的对象是否是一个类的实例

有抽象方法的类一定是抽象类
抽象类就一定有抽象方法吗?不一定
抽象类不能实例化 Pet pet = new Pet();
抽象类的子类可以是普通类,该普通类要实现抽象类中的抽象方法
抽象类的子类也可以是抽象类,此时,父类中的抽象方法可以在子类中不被实现

2.向上转型

向上转型:父类的引用指向子类对象.自动进行类型转换
Pet pet = new Dog();
<父类型> <引用变量名> = new <子类型> ();
此时通过父类引用变量调用的方法是子类覆盖或继承父类的方法,不是父类的方法.
此时通过父类引用变量无法调用子类特有的方法
3.向下转型
如果需要调用子类特有的方法?
向下转型: 将一个指向子类对象的父类引用赋给一个子类的引用,即:父类类型转换为子类类型.需强制类型转换
Dog dog = (Dog) pet; // 将pet转换为Dog类型
<子类型> <引用变量名> = (<子类型>) <父类型的引用变量>;
在向下转型的过程中,如果煤油转换为真实子类类型,会出现类型转换异常
类型转换异常:

image.png

4.instanceof
如何减少在向下转型的过程中,没有转换为真实子类类型的转换异常?
Java中提供了instanceof运算符来进行类型的判断
注意
使用instanceof时,对象的类型必须和instanceof后面的参数所指定的类在继承上有上下级关系

Pet  dog= new  Dog();
if (dog instanceof  Dog) {
Dog d = (Dog) dog;
d.catchFly();
}else  if (dog  instanceof  Penguin){
Penguin  p = (Penguin)  dog;
p.swim();
}

八.抽象类与接口

1.抽象类与抽象方法
public abstract class Pet { // 抽象类
public abstract void toHospital(); // 抽象方法
}

抽象类VS普通类
抽象类不能被实例化
但可以创建一个引用变量,其类型是一个抽象类,指向非抽象的子类实例
普通类可以被实例化

抽象方法VS普通方法
有无方法体

抽象类与抽象方法的使用抽象类中可以没有抽象方法,但包含了抽象方法的类必须被定义为抽象类
如果子类没有实现父类的所有抽象方法,子类必须被定义为抽象类
没有抽象构造方法,也没有抽象静态方法
抽象类中可以有非抽象的构造方法,创建子类的实例时可能调用

2.接口

image.png

接口特性:

接口中的成员变量
默认都是public static final(静态常量 )的,必须显示初始化
接口中的方法
默认都是public abstract的
除了成员遍量和方法,不能包含其他
实现类必须实现接口的所有方法
接口中没有狗造方法,不能被实例化
一格接口不能实现另一个接口,但可以实现类可以实现多个接口 (Java中的多继承)
implements, 多个接口使用逗号隔开

示例:防盗门功能

image.png

阅读代码找出错误:

image.png

1.不能有构造方法
3.不能有普通方法'
4.应是public, 不能private私有化;
3.抽象类vs接口

相同点:
代表系统的抽象层
都不能被实例化
都能包含抽象方法(用于描述系统提供的服务,不必提供具体实现)
不同点:
在抽象类中可以为部分方法提供默认实现,而接口中只能包含抽象方法
一个类只能继承一个直接的父类,但可以实现多个接口
已存在的继承树,可以方便的抽取接口,但是抽取抽象类不容易
使用原则:
接口做系统与外界交互的窗口(接口提供服务)
接口本身一旦制定,就不允许随意修改
抽象类可完成部分功能实现,还有部分功能可作为系统的扩展点

Java面向对象

Java面向对象

一,需要掌握:

二.开发方法

1.结构化开发(基于c语言)

2.面向对象开发

三.类与对象

四.构造方法与方法重载

五.封装

六.继承

七.多态

八.抽象类与接口

示例:防盗门功能

阅读代码找出错误:

Java面向对象

一,需要掌握:

二.开发方法

1.结构化开发(基于c语言)

2.面向对象开发

三.类与对象

四.构造方法与方法重载

五.封装

六.继承

七.多态

八.抽象类与接口

示例:防盗门功能

阅读代码 找出错误:

阅读代码找出错误: