java类和对象详解

Posted 2020-12-31 lw687a

             对象和类详解

       什么是对象：万物皆对象，什么东西都是对象，例如，猫狗人

     什么是类：类是同一事物的统称，它描述一类对象的行为和状态。

    设计类：抽象过程 类的属性 类的方法

     什么是实例化：由类得到对象这个过程叫做实例化

     对象和类的区别：一个是抽象一个是具体，一个是集合一个是个体等等。一个是魔板一个是实例，一个是数据一个是数据结构等等。

     如何设计类：public class student{}//把类的共同提出提取出来，

                 学生会有什么：名字，年龄，性别，等等，这就是共同特征。

     //共同特征为类的属性，共同行为为类的方法。

            举个栗子：

         属性/成员变量：

         String name;

        int age;

        String sex;

        String Phone;

         方法/成员方法：

        public void Eat() {

            System.out.println("吃饭");

        }

        public void sleep() {

            System.out.println("睡觉");

        }

    （）里面的为参数列表

   最前面的是修饰符，一共有四种修饰符

 public：对任何人都是可用的

 protect：继承的类可以访问以及和private一样的权限

 default：包访问权限，即在整个包内均可被访问

 private：除类型创建者和类型的内部方法之外的任何人都不能访问的元素

   第二个表示返回值类型，void表示返回为空

       其他返回值类型需要返回对应的类型。return什么什么

      类的实例化：举例

Student s=new Student();

        System.out.println(s);

        //打印对象的时候相当于输出了对象的toString方法

        System.out.println(s.toString());

        //类里面没有toString方法会输出什么呢

        /**

         * public String toString() {

         * return getClass().getName() + "@" + Integer.toHexString(hashCode());

         */

    //为什么需要重写toString方法？
        如果类没有toSting方法，会默认调用他的父类的toString方法，如果没有父类，会调用他的超类object的toString

        实在不会写就。。。，把Obj的复制过来，然后改一下，当然我会自动生成，零基础还是自己写吧，哈哈哈

     类的作用是什么：方便要由类，方便得到实例，方便操作实例，

     对象实例化时，内存是如何操作的。（问题：对象初始化时，默认值初始值问题）

       对应数据类型的默认值，int是0,double是0.0，char是空白字符 对象类型是null等等

       为什么是这样子呢，emmmm，本来想画个图的，但是我画图技术不行，举个栗子吧，比如你去叫人给你找个对象，你没和别人说你要高矮胖瘦，什么性格，什么年龄等等，别人也不方便给你找对吧。万一你喜欢胖胖的大妈呢，是吧。所以人家暂时也不知道你需要什么类型的就给你默认的符合大众的。

        构造方法：每个类都有构造方法。如果没有显式地为类定义构造方法，Java编译器将会为该类提供一个默认构造方法。一个类可以有多个构造方法，可以写参数也可以不写参数。

public Student() {//无参构造方法

            // TODO Auto-generated constructor stub

        }

        public Student(String name, int age, String sex, String phone) {        //有参构造方法

            super();

            this.name = name;

            this.age = age;

            this.sex = sex;

            Phone = phone;

        }  

方法重载：多个方法拥有相同的名字但是参数传递不一样。

public class Method {

 /**

  * 方法重载

  * 方法名相同

  * 方法的参数类型，参数数量不一样

  * 方法的返回类型可以不相同

  * 方法的修饰符可以不相同

  * main方法也可以重载

  */

 public void show() {

  // TODO Auto-generated method stub

  System.out.println("weIcome");

 }

 public void show(String name) {

  System.out.println("weIcome"+name);

 }

 public void show(String name,int age){

  System.out.println("weIcome"+name+age);

 }

 public void print() {

  // TODO Auto-generated method stub

  System.out.println("无参构造方法");

 }

 public void print(int a){

  System.out.println(a);

 }

 public void print(String name,int a){

  System.out.println("这是什么的名字"+name+a);

 }

 public void nosta(){

  System.out.println("静态方法中不能直接调用非静态方法");

 }

 /**

  * 构造方法

  * 使用new+构造方法 创建一个新的对象

  * 构造方法是定义在java类中的一个用来初始化对象的方法

  * 构造方法与类名相同且没有返回值

  * 

  * 语法

  * 没有返回值类型 与类名相同 有无参构造方法

  * public 构造方法名(){

  * }

  */

 public Method() {

  // TODO Auto-generated constructor stub

  System.out.println("无参的构造方法");

 }

 float screen;

 float cpu;

 float mem;

 public Method(float newScreen,float newCpu,float newMen ){

  //给成员变量赋值

  screen=newScreen;

  cpu=newCpu;

  mem=newMen;

  System.out.println("有参数的方法执行了"+screen+cpu+mem);

 }

 /*

  * java中的static使用之静态变量

  * static修饰的成员被称为静态成员或类成员

  * 它属于整个类所有，而不是某个对象所有

  * 相当于是所有类都拥有它 

  * 静态成员可以使用类名直接访问

  * 也可以使用对象名访问

  * 因为它的特殊性，（建议使用类名访问）

  */

 public static String hobby="imooc";//定义一个静态变量hobby

 String name="我是谁我要干嘛";

 public static void println(){

  Method me=new Method();

  System.out.println("欢迎您：主人有什么可以帮助您的：："+hobby);

  //System.out.println("欢迎您：主人有什么可以帮助您的"+name);

  //静态方法不能直接调用非静态成员

  

  System.out.println("您可能中毒了：需要去："+me.name);

  //通过对象来实现这静态方法中调用非静态变量

 }

 public static void main(String[] args) {

  Method me=new Method();//通过无参的构造方法可以创建对象

  Method met=new Method(5.0f,1.4f,2.0f);//通过有参的构造方法也可以创建对象

  //当没有指定构方法时，系统会自动添加无参的构造方法

  //当有指定构造方法时，

  //无论是有参或者无参的构造方法都不会添加自动添加无参构造方法

  me.show("这",20);

  me.print("name", 15);

  //构造方法重载：和方法重载一样

  //构造方法不但可以给对象的属性赋值，

  //还可以保证给对象的属性赋一个合理的值

  

  System.out.println("通过类名访问hobby"+Method.hobby);

  //静态变量可以直接使用类名来访问，无需创建类的对象

  

  System.out.println("通过对象名访问hobby"+me.hobby);

  //使用对象名来访问静态变量

  

  me.hobby="我一天不装逼就不舒服";

  System.out.println("通过类名访问hobby："+Method.hobby);

  //再次使用类名访问静态变量，值已被修改

  

  Method.println();//使用对象名直接调用

  me.println();//使用对象名调用方法

  

  

  me.nosta();

  //静态方法中不能直接调用非静态方法，需要通过对象来访问

 }

} 

     this的作用：区分成员变量和形式参数，this可以省略

            

    java面向对象的四大特性：

            封装;是指一种将抽象性函式接口的实现细节部份包装、隐藏起来的方法。

public class Persons {

    private int preID;//id

    private String preName;//名字

    private String prePass;//密码

    private String ptrEmail;//邮箱

    private int preAge;//年龄

    private String preAddress;//地址

    private String preCity;//现居城市

    

    public Persons() {

        super();

        // TODO Auto-generated constructor stub

    }

    public Persons(int preID, String preName, String prePass, String ptrEmail, int preAge, String preAddress,

            String preCity) {

        super();

        this.preID = preID;

        this.preName = preName;

        this.prePass = prePass;

        this.ptrEmail = ptrEmail;

        this.preAge = preAge;

        this.preAddress = preAddress;

        this.preCity = preCity;

    }

    @Override

    public int hashCode() {

        // TODO Auto-generated method stub

        return super.hashCode();

    }

    @Override

    public boolean equals(Object obj) {

        // TODO Auto-generated method stub

        return super.equals(obj);

    }

    @Override

    protected Object clone() throws CloneNotSupportedException {

        // TODO Auto-generated method stub

        return super.clone();

    }

    @Override

    public String toString() {

        return "Persons [preID=" + preID + ", preName=" + preName + ", prePass=" + prePass + ", ptrEmail=" + ptrEmail

                + ", preAge=" + preAge + ", preAddress=" + preAddress + ", preCity=" + preCity + "]";

    }

    @Override

    protected void finalize() throws Throwable {

        // TODO Auto-generated method stub

        super.finalize();

    }

    public int getPreID() {

        return preID;

    }

    public void setPreID(int preID) {

        this.preID = preID;

    }

    public String getPreName() {

        return preName;

    }

    public void setPreName(String preName) {

        this.preName = preName;

    }

    public String getPrePass() {

        return prePass;

    }

    public void setPrePass(String prePass) {

        this.prePass = prePass;

    }

    public String getPtrEmail() {

        return ptrEmail;

    }

    public void setPtrEmail(String ptrEmail) {

        this.ptrEmail = ptrEmail;

    }

    public int getPreAge() {

        return preAge;

    }

    public void setPreAge(int preAge) {

        this.preAge = preAge;

    }

    public String getPreAddress() {

        return preAddress;

    }

    public void setPreAddress(String preAddress) {

        this.preAddress = preAddress;

    }

    public String getPreCity() {

        return preCity;

    }

    public void setPreCity(String preCity) {

        this.preCity = preCity;

    }

        继承：比如我儿子们继承我的东西（皮使我开心。），

                      Java这里继承的实体是类，也就是说继承子类拥有父类的成员

                        java是单继承的继承的好处：子类就直接拥有了父类的所有属性和方法

                    子类可以复用父类的

                        在类的设计中，可以通过关键字extends来指明其父类

                        语法： 修饰符 class 子类名字 父类名字

                        方法重写

    如果子类对继承父类的方法不满意，是可以重写

    父类继承的方法的，当调用方法时，会优先调用

    子类重写的方法

    语法规则 : 返回值类型 方法名和参数类型都必须

    要与父类继承的方法相同,才叫做方法重写

  public class pig extends Animal{

   public String paolu;

   public String chihenduo;

   public void syso() {

    // TODO Auto-generated method stub

    System.out.println("你是猪");

   }

// public void eat() {//实例方法的重写

// // TODO Auto-generated method stub

// System.out.println("猪拥有吃很多东西的能力");

// }//已经被final

   public pig(){

    System.out.println("我要输出什么呢");

   }

// 继承的初始化顺序

// 1.初始化父类再初始化子类

// 2.先执行初始化对象中属性,再执行构造方法中的初始化

// 父类对象=》属性初始化=》构造方法=》

// 子类对象=》子类属性的初始化=》构造方法

   /**

    * final关键字

    * 使用final关键字做标示有“最终的”含义

    * final可以修饰类 方法 属性和变量

    * final修饰类，则该类不允许被继承

    * final修饰方法，则标示该方法不能重写

    * final修饰变量，只能赋值一次

    * @return 

    */

// final void piga(){}

// final void piga(int a){

//    

// }

  }

  super关键字：在对象中使用，可以代表父类对象

        super可以调用父类的属性和方法。

        super点属性或者方法就行  

多态：对象的多种形态，同一个行为具有多个不同表现形式，

        举个栗子：比如你老师，你是不是有高数，英语，java等等老师。

        引用多态：父类的引用可以指向子本类的对象/子类的对象

        方法多态：创建本类对象时，调用的为子类的方法。

                  创建子类对象时，调用方法为子类重写的方法或者继承的方法。

抽象类： 一个抽象的类，一个类中没有包含足够的信息来描绘一个具体的对象。

      package demo1;

 

public abstract class abstrtel {

 /**

  * 抽象类

  * 语法定义：

  * 抽象类前使用abstract关键字修饰，则该类为抽象类

  * 应用场景：

  * 某写情况下，某个父类只是知道其子类应该包含怎样的方法，

  * 但无法准确知道这些子类如何实现这些方法

  * 抽象类是约束子类必须包含什么样的方法

  * 

  * 从某个具有相同特征的类中抽象出一个抽象类，以这个抽象类

  * 作为子类的模板，从而避免了子类设计的随意性

  *   

  * 作用：不关注子类的实现，但是限制规定子类必须实现某些方法，

  * 但是不注意细节

  * 

  * 使用规则：

  * a.abstract定义抽象类

  * b.absteact定义抽象方法，只有声明，不需要实现

  * c.包含抽象方法的类是抽象类

  * d.抽象类中可以包含普通的方法，也可以没有抽象方法

  */

 public abstract void call();//抽象方法

 public abstract void message();//

 

}

        类的初始化过程：

        .java的源代码文件通过javac.exe这个文件将他编译成.class的字节码文件。

        源码要运行，必须先转成二进制的机器码。这是编译器的任务。

        然后class文件通过字节码的方式传输到类加载器，（传输的对象就是本地字节码和网络传输）。

        类加载器通常由jvm来提供，我们称为系统类加载器，我们也可以继承classloader类来提供自定义类加载器。同时会调用本地的内裤。

        类加载器分为三种：bootstrap加载器（这个不是前端的框架那个），application加载器和忘了。。。

        不同的类加载器可以实现加载本地字节码文件，jar包和war包中的字节码，通过网络加载字节码等等。万物皆对象，类是用来描述对象的，那谁来描述类这个对象呢，就用java.lang.Class对象来描述。java.lang.Class也作为方法区这个类的各种数据的入口。

         当调用java命令来运行某个java程序时，该命令将会启动一个jvm进程。同一个jvm‘中的所有线程变量都处同一个进程中，共享该jvm的内存区域.

   当出现以下情况会让jvm退出

        1.程序正常执行结束，

         2.使用system.exit()方法；

          3.出现异常时，没有捕获异常

          4.平台强制结束jvm进程

        jvm一旦结束，该进程中内存中的数据将会丢失

         然后检测被加载的类是否有正常的内部结构，这一阶段的主要目的是为了确保Class文件的字节流中包含的信息是否符合当前虚拟机的要求，并且不会危害虚拟机自身的安全。

        开始给类变量分配内存，并给初始值。

       然后虚拟机将常量池中类的二进制数据中的符号引用替换为直接引用。

        直接引用：直接引用到某块内存空间

        注意：除了在加载阶段可以自定义类加载器以外，其它操作都由JVM主导。

         java8以后会把方法区放在堆里面了；

         这个还是举例子吧；

               woman w=new woman();

               首先会先把这个类里面的元信息加载到方法区（jdk8以后堆方法区就在堆里面了。）元信息：什么构造方法，属性，方法等等。然后会用new关键字来在堆内存里面去申请一块空间（任何情况下，只要看见关键字new，都表示要分配新的堆内存空间，一旦堆内存空间分配了，里面就会有类中定义的属性）。把我们的new woman()存储进去，当调用狗杂方法的时候，会把方法区非静态的成员属性给到堆里面去。再把他值传过去，没赋值就是默认值。再把内存地址放到栈内存里面去就是w。所以java没有引用传递，只有值传递。当你通过w去操作的时候其实是操作的new woman()这块内存地址。

        引用传递：woman w = new woman () ; // 声明并实例化对象

             w1.name = "张三" ;

             w1.age = 20 ; 

             woman w2= w1 ; // 引用传递 

             w1.name = "李四" ; w1.Eat() ;