面向对象基础知识回顾

1. 变量（四类八种），结构，数组
1）变量：整型（byte1个字节，short2个字节，int4个字节，long8个字节），实型（float4个字节，double8个字节），字符型（char2个字节）和布尔型（boolean1个字节 true和false）
2）结构：顺序结构，选择结构（if，if-else，switch），循环结构（while，do-while，for）
3）数组：int[] a = new int[5];
4）方法：

public class Demo01 {
    public static void main(String[] args) {
        //从键盘中输入3个整数，把他存在整形数组中，并计算数组中的平均值，以及找到最大值和最小值
        Scanner scanner=new Scanner(System.in);
        int []a=new int[3];
        System.out.println("请输入3个整数");
        for (int i=0;i<a.length;i++){
            a[i]=scanner.nextInt();
        }
        System.out.println("输入完毕");
        System.out.println("您输入的数据为");
        print(a);
        calAvg(a);
        find(a);
    }
    //方法能够独立完成一个功能模块的代码的集合
    public static void print(int[] a){
        for (int i=0;i<a.length;i++){
            System.out.println(a[i]+"\t");
        }
    }
    public static void calAvg(int []a){
        int sum=0;
        for (int i=0;i<a.length;i++){
            sum+=a[i];
        }
        System.out.println("平均值"+1.0*sum/a.length);
        //除法时，java规定整数除整数，结果只能为整数，而且不做四舍五入
    }
    public static void find(int[]a){
        int max=a[0];
        int min=a[0];
        for (int i=1;i<a.length;i++){
            if(a[i]>max){
                max=a[i];
            }
            if(a[i]<min){
                min=a[i];
            }
        }
        System.out.println(max+","+min);
    }
}

2. 面向对象：基本概念
1）类：具有相同特性的物体归为一类 class （实体类对象entity domain vo ）
2）对象：使用的时候，使用的是一个具体的个体，这个个体叫做对象，对象是类的一个实例（instance）
3）属性：静态的特性
4）方法：动态的特性

内存的使用情况
栈堆常量区代码区
对象的引用

5）构造方法：为了在对象初始化的时候能够给属性赋值，这个特殊的方法就是构造方法。方法名必须和类名一致，不能有返回值
a）每个类在创建的时候，都会默认生成一个参数为空，方法体也为空的构造方法，当定义了显性的构造方法之后，默认为空的构造方法就消失了

Person person=new Person();//new调用构造方法

6）this关键字：代词，用来指代当前对象
7）访问权限修饰符
本类中本包中子类中任意位置
private 可以不可以不可以不可以
默认可以可以不可以不可以
protected 可以可以可以不可以
public 可以可以可以可以

属性一律声明成私有的，方法一般声明为公有的

get set方法组来改变私有属性的值

toString方法是为了在测试的时候，检查对象的属性是否正确，没有的话打印的是散列码，

散列码相同是一个对象

8）方法的重载（overload）：方法名相同，参数列表不同的方法，构成了方法的重载
注意，参数列表不同指的是参数的类型不同，或者参数的个数不同
构造方法也可以重载，普通方法也可以重载

//求各种图像的面积，可以是圆等等
public class Demo03 {
    public static void main(String[] args) {
        CalcArea calcArea=new CalcArea();
        calcArea.calcArea(3);
        calcArea.calcArea(1,2);
    }
}
class CalcArea{
    public double calcArea(double r){
        return Math.PI*r*r;
    }
    public double calcArea(double l,double w){
        return l*w;
    }
}

9）static 关键字：类方法或者类属性
整个类体现出来的方法和属性，定义为static的
通过类名去调用类属性和类方法，不能使用对象调用

10）类和类之间的关系
a）依赖关系：一个对象作为另一个对象的参数或者是宾语
b）聚合关系：一个对象作为另一个对象的属性存在
c）继承关系：谁是谁的一种

11）继承：
super关键字的作用的作用，子类调用父类的方法，super只能出现在子类里。super( ，);
a)目的：为了实现代码的重用性
b）机制：继承是父类和子类自检共享数据和方法的机制
c）继承分为单继承和多继承，Java只支持单继承的。
d）继承的关键字是extends
e）子类可以继承父类的所有的非私有的属性和方法，继承使子类可以利用父类定义的属性和方法，就像子类本身就具有一样的

继承的构造方法
子类和父类的构造方法要一致，系统会先默认调用父类的构造方法，如果父类定义了显性的构方法，子类也要定义显性的构造方法，而且使用super调用父类的构造方法，并且必须在第一条语句
构造方法不能被继承，但是可以被调用

f）重写（override）：子类对父类的方法不满意的时候，可以选择重写父类的方法，注意，重写只能出现在子类中。
格式：和父类的方法名相同，并且参数列表也相同，而且要有相同的返回值类型，子类重写父类的方法，其权限不可低于父类的权限
子类中的成员变量和父类中的成员变量名字相同时，子类的成员变量会覆盖父类的成员变量

g）super关键字：在子类中，调用父类的非构造方法时，super.

12) 抽象类：也是出现在继承中
抽象方法：只定义，但是没有实现的必要 public abstract void eat();
含有抽象方法的类，叫做抽象类
关键字是：abstract
子类继承一个抽象类之后，可以选择实现父类的所有的抽象方法，子类就是一个正常的类了，如果没有全部实现父类的抽象方法，子类也是一个抽象类
抽象类不是一个完整的类，不能直接用new实例化对象。

Student student=new Student(name: "学生1"，age:30){

@Override

public void eat(){ //匿名内部类

}

};

13）接口是抽象方法和常量的集合，默认接口的所有的方法都是public abstract的，默认所有的成员变量都是public static final的
a）变相实现了多继承，子类类在继承一个类的同时，可以实现多个接口。
b)关键字是：interface 类继承接口 implements
c）接口和接口或者类和类构成继承关系用extends关键字如List<T>,Collection<T>,Iterable<T>

Comparable<T>,Comparator<T>都是接口，作用比较器排序

(1)Comparable用法，先让定义数组的类实现接口，并且重写comparaTo方法，用Arrays.sort（数组）

1.  public class Student extends Person implements Comparable<Student> {}

2.

//根据compareTo方法的语句和返回值，决定排序条件
  @Override
  public int compareTo(Student o) {//o是object
      return this.score-o.score;//(-1)*(this.score-o.score)倒序

//this.getName().compareTo(o.getName()）按名字排序

  }

3.

       // Arrays.sort(students);
//        for(int i=0;i<students.length;i++){
//            System.out.println(students[i]);
//        }

(2)Comparator用法：实现Comparator方法，Arrays.sort()

public class MyComparator implements Comparator<Student> {
    @Override
    public int compare(Student o1, Student o2) {
        return o1.getScore()-o2.getScore();
    }
}

2.

Arrays.sort(students,new MyComparator());
for (Student stu:students) {
    System.out.println(stu);
}

14）foreach（）：用来遍历数组和集合，是for循环一个简便方式，缺点，foreach循环不能通过循环控制变量进行逻辑

15）final关键字，出现在继承里，终态的意思
final修饰的类，不能被继承的
final修饰的方法，是不能是重写的
final修饰的变量，是不能被修改的

16）对象的转型：分为上转型和下转型
上转型：子类对象可以被视为是其父类的一个对象
下转型：父类当做子类看待是不可以的
上转型的格式：父类声明 = 用子类实例化
上转型对象不能访问子类特有的方法的，但是可以访问子类重写的父类的方法，并且访问结果是子类的方法

17)instanceOf:判断某个对象是不是某类的对象，或者是不是这个类的子类的对象

 //转型
        Person p1=new Student("yyj",4,"female",3);
      //  Student s1=new Person();这个不行，从右往左赋值
        p1.eat();//继承关系中当子类重写父类方法，上转型访问子类的方法
//        Student s=(Student) p1;//下转型 强转
//        s.play();

        //instanceof 判断是不是某一类对象
        System.out.println(p1 instanceof Student);

posted @ 2021-03-11 11:55 YangYuJia 阅读(99) 评论(0) 收藏举报

刷新页面返回顶部

YangYuJia

面向对象基础知识回顾

公告