JAVA学习(六)

笔记
super注意点
1.super调用父类的构造方法，必须在构造方法的第一个
2.super必须只能出现在子类的方法或者构造方法中
3.super和this不能同时调用构造方法！
VS this
代表的对象不同：
this：本身调用者这个对象
super：代表父类对象的应用
前提
this：没有继承也可以使用
super：继承条件才能使用
构造方法
this()：本类的构造
super：父类的构造

重写：需要有继承关系，子类重写父类的方法
1.方法名必须相同
2.参数列表必须相同
3.修饰符：范围可以扩大，但是不能缩小 public > propected >default>private
4.抛出的异常：范围可以被缩小，但不可以被扩大 ClassNotFoundException–>Exception
重写，子类方法和父类必须要一致，方法体不同

为什么需要重写？
因为父类的功能子类不一定需要，或者不一定满足
override

权限访问。
//public 公共的
//protected受保护的
//default 默认的
//private 私有的

//在java中所有的类都直接或间接继承Object
// 类型之间的转换： 父 子
// 子类转换为父类，可能会丢失自己本来的一些方法
Person student = new Student();
// student将这个对象转换为Student类型 我们就可以使用Student类型的方法了
((Student)student).go();
/*

• 1.父类引用指向子类的对象
• 2.把子类转换为父类，向上转型；
• 3.把父类转换为子类，向下转型，需要强制转换，强制转换可能会丢失一些方法
• 4.方便方法的调用，减少重复的代码，简洁代码
• 封装继承多态
• */

/*

• 多态的注意事项
• 1.多态是方法的多态，属性没有多态
• 2.父类和子类，有联系 类型转换异常 ClassCastException
• 3.存在条件，继承关系，方法需要重写,父类的引用指向子类对象father f1 = new Son();
• 1.static 属于类，它不属于实例
• 2.final 是常量
• 3.private 私有方法
  约束~有人帮我们实现
  // abstract 抽象方法，只有方法名字没有方法的实现
  // abstract 抽象类 类 extends 单继承 (接口可以多继承)
  // 1.不能new这个抽象类：只能靠子类去实现它，约束
  // 2.抽象类里面可以写普通方法
  // 3.抽象方法必须在抽象类中
  // 抽象的抽象：约束
  // 思考，new?存在构造器么
  // 抽象类存在的意义 提高开发效率

接口的作用

1.约束
2.定义一些方法，让不同的人实现~~ 10 ----> 1
3.public abstract
4.public static final
5.接口不能被实例化~接口中没有构造方法
6.implements可以实现多个接口
7.必须要重写接口中的所有方法。

import java.io.IOException;

public class Demo01 {
//    main方法
    public static void main(String[] args) {

    }


//    修饰符 返回值类型  方法名(.....){//方法体  return 返回值;}
//    return结束方法 返回一个结果
    public String sayHello(){
        return "hello world";
    }
    public int max(int a,int b){
        return a > b ? a : b; //三元运算符
    }
//    数组下标越界:  Arrayindexoutofbounds
    public void readFile(String file) throws IOException{

    }
}

public class Person {
//    构造方法必须与类名相同
//    不能有void
    String name;

//    实例化，初始值
//    1.使用new关键字必须要有构造器


    public Person() {
//        空参构造
    }

    //    有参构造
//    一旦定义了有参构造，无参必须显示定义
    public Person(String name){
        this.name = name;
    }
}
/*
*  构造方法必须与类名相同
   不能有void
   new 实例化一个对象本质是在调用构造方法
   构造器用来初始化值
   一旦定义了有参构造，无参必须显示定义
 public static void main(String[] args) {
//   new 实例化一个对象
//  构造器用来初始化值
    System.out.println(person.name);
    *
    * ALT + INSERT
 */

package oop.demo02;
//学生类

public class Student {
//    属性:字段
    String name;//null
    int age;//0
//    方法
    public void study(){
        System.out.println(this.name+"在学习");
    }

}
//学程序好？对世界进行更好的建模！---宅！
/*
*       类是抽象的 需要实例化
        类实例化后会返回一个自己的对象
        student对象就是一个Student类的具体实例
        Student xiaohong = new Student();
        Student xiaoming = new Student();
        xiaohong.name = "小红";
        xiaohong.age = 10;
        System.out.println(xiaohong.name);
        System.out.println(xiaohong.age);
* */

public class Pet {
    public String name;
    public int age;
    public void shout(){
        System.out.println("叫了一声");
    }
}

/*
        Pet dog = new Pet();
        dog.name = "旺财" ;
        dog.age = 3;
        dog.shout();
        System.out.println(dog.name);
        System.out.println(dog.age);
* */
/*
* 1.类与对象
* 类是一个模板：抽象，对象是一个具体的实例
* 2.方法
* 定义，调用
* 3.对应的引用
* 引用类型 基本类型（8）
* 对象是通过引用来操作的：栈--->堆
* 4.属性：字段Filed 成员变量
* 默认初始化：
* 数字:0 0.0
* char: u0000
* boolean:false
* 引用 null
*   修饰符 属性类型  属性名 = 属性值！
* 5.对象的创建和使用
* 必须使用new关键字创建对象，构造器 Person s = new Person();
* 对象的属性s.name
* 对象的发放s.sleep()
* 6.类
* 静态的属性   属性
* 动态的行为   方法
* */

public class Student {
    //名字
    private String name;
    //学号
    private int id;
    //性别
    private char sex;
    //年龄
    private int age;
//提供一些可以操作这个属性的方法
//    提供一些public 的get  set 方法
//    get 获得这个属性   set给这个属性设置默认值

    public void setAge(int age) {
        if (age>120 || age<0){
             this.age = 3;
        }else {
           this.age = age;
        }

    }

    public int getAge() {
        return age;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setId(int id) {
        this.id = id;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    public String getName() {
        return name;
    }

    public int getId() {
        return id;
    }

    public char getSex() {
        return sex;
    }
    //学习()
    //睡觉()
}


/*
* 1.提到程序的安全性，保护数据
* 2.隐藏代码的实现细节
* 3.统一接口
* 4.提高系统的可维护性
* */
/*
*
       Student s1 = new Student();
        s1.setName("王者");
        s1.setId(1);
        System.out.println(s1.getId());
        System.out.println(s1.getName());
        s1.setAge(70);
        System.out.println(s1.getAge());
* */

public class Outer {

}
/*
*
    private int id = 10;
    public void out(){
        System.out.println("这是外部类的方法");
    }
//    内部类
    public  class Inner{
        public void in(){
            System.out.println("这是内部类的方法");
        }
//        获得外部类的私有属性

    }
*
* Outer outer = new Outer();
        Outer.Inner inner = outer.new Inner();
        inner.in();
        inner.getID();
* */
/*
* //        局部内部类
    public void method(){
        class Inner{
            public void in(){

            }
        }
    }
* */
//一个java类中可以有多个class类但是只能有一个public class