Day06

最新推荐文章于 2024-07-14 22:26:46 发布

eternal_20

最新推荐文章于 2024-07-14 22:26:46 发布

阅读量45

点赞数

文章标签： java 开发语言学习 intellij-idea

本文链接：https://blog.csdn.net/eternal_20/article/details/123364943

版权

对象

面向对象和面向过程

面向对象的本质是：

以类的方式组织代码，以对象组织（封装）数据。

三大特性：封装，继承，多态

调用其他类方法：

1.方法有static直接调用

2.没有先实例化这个类再调用

对象类型对象名 = 对象值

alt + insert

public class Demo01 {
    public static void main(String[] args) {
        //实例化这个类 new
        //对象类型   对象名字   =   对象值
        Student student = new Student();
        student.say();
    }
    public  String sayHello(){
        return "hello,world";
    }

//和类一起加载的
    public static void  a(){

    }
    //类实例化之后才存在
    public void b(){

    }
}
public class Student {

    //静态方法 static

    //非静态方法
    public  void say(){
        System.out.println("学生说话了");
    }
}

创建与初始化对象

*使用new关键字创建对象

*new创建关键字时除了分配空间还会进行默认初始化，以及对类中构造函数的调用

//一个项目只存在一个main
public class Application {
    public static void main(String[] args) {

       Person person = new Person();

       System.out.println(person.name);

    }
}
//类： 抽象的 ：实例化
//        //类实例化后会返回一个自己的对象
//        //student对象就是Student类的具体实例对象
//
//          Student xiao = new Student();
//          Student  dao = new Student();
//          xiao.name = "雄安命";
//          xiao.age = 20;
//          dao.name = "小红";
//        dao.age = 21;
//
//          System.out.println(xiao.name);
//          System.out.println(xiao.age);
//          System.out.println(dao.name);
//          System.out.println(dao.age);
//

public class Person {
    //一个类什么都不写也会存在一个方法
    String name;
    public Person(){
        this.name = "3333";
    }
    //实例化初始值
    //1.使用new 关键字，必须要有构造器,本质调用构造器
    //2.用来初始化值

    //有参构造:一旦定义了有参构造，无参就必须显示
    public Person(String name){
        this.name = name;
    }
}
//alt + insert 创建构造方法

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

构造方法的俩个特点：

1.必须相同与类的名字

2.必须没有返回值也不能写void

一个类什么都没有会有默认构造方法。

有参构造与无参构造：

作用：

1.new本质在调用构造方法

2.初始化对象的值

注：定义了有参构造想使用无参构造，得显示定义一个无参构造。

封装：

我们程序要“高内聚，低耦合”

属性私有，get/set

Alt+fn+insert

封装的作用：

1.提高程序稳定性

2.隐藏代码实现的细节

3.统一接口

4.系统维护性增加

//封装
//1.提高程序安全性
//2.隐藏代码实现细节
//3.统一接口
//4.系统维护性增加了
public class Application {
    public static void main(String[] args) {
        Student s1 = new Student();

        s1.setName("丁丁");
        System.out.println(s1.getName());
        s1.setAge(130);

    }


}

public class Student {
    //属性私有
    //名字
    private  String name;
    //学号
    private int id;
    //性别
    private char sex;
    private int age;
  //提供一些操作这个属性的方法
    //提供一个public 的get,set方法
    //get 获得这个方法
    public String getName(){
        return this.name;
    }
    //set 给这个数据设置值
    public void setName(String name){
        this.name = name;
    }

    public char getSex() {
        return sex;
    }

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

    public int getId() {
        return id;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if (age > 120 || age < 0) {
            System.out.println("输错了");
        }else {
            this.age = age;
        }
    }
}

继承：

Object类

super

方法重写

super注：

1.super调用构造方法必须在构造方法第一个。

2.super只能出现在子类方法或者构造方法中

3.super和this不能同时调用构造方法

与this：

代表对象不同：

 this：本身调用这个对象
 super：代表父类的引用

前提：

 this：没有继承也能使用
 super：只能在继承条件下使用

构造方法：

this：调用本类的构造
super：调用父类的构造

public class Application {
    public static void main(String[] args) {
//        Student student = new Student();
//        student.say();
//        System.out.println(student.getMoney());


        Student student = new Student();
       // student.test("庆");
        //student.test1();

    }
}

//Person
//学生  is 人
//java中所有类都直接或者间接继承objcet类
public class Person {
    //public
    //protected
    //default   默认
    //private
  /*  private   int money = 10_0000_0000;

    public int getMoney() {
        return money;
    }

    public void setMoney(int money) {
        this.money = money;
    }

    public void say(){
    System.out.println("说了一句话");

}*/

    public Person() {
        System.out.println("Person无参执行");
    }

    protected String name = "dingding";
//私有的东西无法被继承
public void print(){
    System.out.println("person");
}

}

//子类继承父类，就会有父类全部方法
public class Student extends Person{

    public Student() {
        //隐藏代码：调用了父类的无参构造
        super();   //调用父类的构造方法必须要在
        // 子类构造器的第一行  （默认）
        System.out.println("子类无参执行");
    }

    private  String name = "qing";

    public void print(){
        System.out.println("student");
    }

    public void test1(){
   print();
   this.print();
   super.print();
    }

    public void test(String name){
        System.out.println(name);//输入的
        System.out.println(this.name);//这个类的name
        System.out.println(super.name);//父类的
    }



}

方法重写：

需要有继承关系，子类重写父类的方法（不是属性）；

1.方法名相同

2.参数列表相同

修饰符可以扩大不能缩小

4.抛出异常可以缩小不能扩大

public class Application {
//重写只和非静态方法有关
    //静态的方法和非静态的方法区别：
      //静态方法：     方法的调用只和左边定义的数据类型有关
      //非静态方法：  重写


    public static void main(String[] args) {

         //静态方法：     方法的调用只和左边定义的数据类型有关
        A a = new A();
        a.test();  //调用A类构造方法

        //父类的引用指向子类
        B b = new A();  //子类重写了父类的方法
        b.test();  //调用B类构造方法
    }

}

public class A extends B {
  //override重写
    @Override  //注解：有功能的注释
    public void test() {

            System.out.println("A=>test()");

    }
}

//重写都是方法的重写，和属性无关
public class B {
    public  void test(){
        System.out.println("B=>test()");
    }
}

多态：

注：1.多态是方法的多态

2.父类和子类，有联系

3.存在条件：继承关系，方法需要重写，

从父类引用指向子类

4.static private final 方法不能重写就不能多态。

public class Application {
    public static void main(String[] args) {
        //一个对象实际类型是确定的
        //new Student();
        //new Person();

        //可以指向的引用类型就不确定了: 父类的引用指向子类

        //Student 能调用的方法都是自己的或者继承父类的
        Student s1 = new Student();
        //Person 父类型，可以指向子类，但不能调用子类新增的方法
        Person s2 = new Student();
        Object s3 = new Student();
        Person person = new Person();//重写父类方法不会改变


        //对象能执行哪些方法主要看左边类型，和右边关系不大
        s2.run();//子类重写了父类的方法
        //((Student) s2).eat();  强制转换
        s1.eat();
        s1.run();
        person.run();

    }
}


public class Person {
    public void run(){
        System.out.println("run");
    }
}

public class Student extends Person {
    public void run(){
        System.out.println("son");
    }
    public  void eat(){
        System.out.println("eat");
    }
}

狂神Java