2022/4/24 JavaDay16

 

创建对象内存分析

main方法在栈里面、

static一开始和类一起加载

对象是通过引用来操作：通过栈===》来操作堆

属性：字段Field 成员变量

默认初始化：

  1. 数字：0

  2. char：u0000

  3. boolen：false

  4. 引用：null

修饰符 属性类型 属性名 =属性值

对象的创建和使用

  1. 必须使用new关键字来创造 Person sunkuan =new Person（）；

  2. 对象的属性 sunkuan.name

  3. 对象的方法 sunkuan.sleep();

 package com.oop.demo03;
 ​
 public class Pet {
 ​
     public String name;//别忘了加public
     public int age;
 ​
     public void shout(){
         System.out.println("叫了一声");
     }
 }
 package com.oop;
 ​
 import com.oop.demo03.Pet;
 ​
 public class Application {
     public static void main(String[] args) {
         Pet dog = new Pet();
         dog.name="旺财";
         dog.age=12;
         dog.shout();
         System.out.println(dog.name);
         System.out.println(dog.age);
     }
 }

面向对象三大特性

封装

  • 高内聚，低耦合——内部数据操作细节自己来完成，不允许外部干涉，低耦合：就暴露少量的方法给外部

  • 属性私有

  • get/set

 package com.oop.demo04;
 //类 private
 /*
 * 1.提高程序的安全性
 * 2.隐藏代码的实现细节
 * 3，统一接口
 * 4.系统的可维护性增加了
 * 
 * 
 * */
 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;
     }
 //generate
     public int getId() {
         return id;
     }
 ​
     public void setId(int id) {
         this.id = id;
     }
 ​
     public char getSex() {
         return sex;
     }
 ​
     public void setSex(char sex) {
         this.sex = sex;
     }
 ​
     public int getAge() {
         return age;
     }
 ​
     public void setAge(int age) {
         if ( age>120||age<0 )
         {this.age=3;}
         else {
             this.age = age;
         }
     }
 }
 package com.oop;
 ​
 import com.oop.demo04.Student;
 ​
 public class Application {
     public static void main(String[] args) {
         Student s1 = new Student();
         s1.setName("孙款");
         System.out.println(s1.getName());
 ​
         s1.setAge(999);
         System.out.println(s1.getAge());
     }
 }

继承

继承的本质是对某一批类的抽象

extands的意思就是“扩展”

只有单继承,一个儿子只能有一个爸爸，一个爸爸可以有多个儿子

  1. object类

 package com.oop.demo05;
 //具有is a的意思
 //子类继承父类就会拥有父类全部方法
 //如果修饰符是private，父亲私有
 public class Student extends Person{
     Person person;
 ​
 //ctrl+H看继承的类
 }

  1. super--this

super调用父类，而且隐藏调用父类

父类没有无参，子类则不可以使用无参

  1. super调用父类的构造方法，必须在构造方法第一个

  2. 必须只出现在子类的方法或者构造方法中

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

vs this：

  • this随便，本类

  • super和父类绑定

  • ctrl+F搜索

  1. 方法的重写

静态的方法和非静态区别大

静态方法只和左边有关，非静态可以重写，static来区分

重写：

  1. 需要有继承关系，子类重写父类方法

    • 方法名必须相同

    • 参数列表必须相同

    • 修饰符可以扩大但不可以缩小：publi》proteced》default》private

    • 抛出异常：可以缩小但不可以扩大：classnotfoun

    重写，子类的方法和父类必须一致

    方法体不同

    为什么需要重写：

    1. 父类的功能，子类不一定需要，或者不一定满足

    override重写

    多态

    同一个方法可以根据发送对象的不同而采用多种不同的行为方式

    一个对象的实际类型是确定的，但指向引用类型有很多

    存在条件：

    1. 有继承关系

    2. 子类重写父类

       package com.oop;
 ​
 import com.oop.demo06.Person;
 import com.oop.demo06.Student;
 ​
 public class Application {
     public static void main(String[] args) {
         //一个对象的实际类型是确定的
         //可以引用的类型就不确定
         Student student = new Student();
         Student s1=new Student();
         Person s2=new Student();
         Object s3=new Student();
         s2.run();
         s1.run();//子类重写了父类方法，执行子类方法
         //对象能执行那些方法看对象左边，和右边关系不大
         //儿子都可以用，父亲只可以调用自己的，父亲要调用要类型转换
     }
 /*
 * 1.多态是方法的多态
 *2.父类和子类有关系，；类型转换异常，ClassCastException
 * 3.存在条件：继承，方法重写，父亲引用指向子类
 * */
 ​
 }

    1. static 属于类，不属于实例

    2. final不可以重写

    3. private方法也不可以重写

    instanceof（类型转换）

    包含于关系

    类型转换：高转低

     ((Student)obj).go();//强制转换

    子转父可能会丢失子类拓展的方法，向上转型不用强转

    方便调用

    Static

    共享性，有static可以直接调

     static{
     //静态代码块，且只执行一次
 }
 {
     //匿名代码块，可以赋初值
 }
 静态导入包

    静态》匿名》构造方法

抽象类

 public abstract class a{
     public abstract void b();
     //抽象方法，只有方法名字，没有方法的实现
 }

父债子偿——必须重写

extends：单继承 接口可以多继承

  1. 不可以new，只可以靠约束

  2. 抽象类里面可以写普通方法，抽象方法必须在抽象类中

接口

只有规范，专业的约束，约束和实现的分离

interface

 package com.oop.demo09;
 //类可以实现接口，implements来实现，
 //实现了接口的类，就要重写接口的方法
 //多继承，接口只有方法的定义
 public class UserServiceImpl implements UserService,TimeService{
     @Override
     public void add(String name) {
 ​
     }
 ​
     @Override
     public void delete(String name) {
 ​
     }
 ​
     @Override
     public void update(String name) {
 ​
     }
 ​
     @Override
     public void query(String name) {
 ​
     }
 ​
     @Override
     public void timer() {
 ​
     }
 }
 作用：
 1.约束
 2.定义一些方法，让不同人实现
 3.public abstract
 4.public static final
 5.接口不能被实例化
 6，implement可以实现多个接口
 7，必须要重写接口中的方法，generate

内部类

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

异常

Exception

异常体系结构

  1. 检查性异常-----是个人问题

  2. 运行时异常，可处理

  3. 错误ERROR----和个人没关系

异常处理机制

  1. 抛出异常

  2. 捕获异常

try ,catch,throw,

 package com.exception;
 ​
 public class Test {
     public static void main(String[] args) {
         int a=1;
         int b=0;
         new Test().test(1,0);
         //处理不了主动抛出异常
 ​
     }
     public  void test(int a,int b){
 ​
             if ( b==0 ){
                 throw new ArithmeticException();//主动抛出异常
             }
     }
     /* try{//try监控区域
             if ( b==0 ){
                 throw new ArithmeticException();//主动抛出异常
             }
             System.out.println(a/b);
         }catch (Error e){//想要捕获的错误类型
             System.out.println("程序出错，变量b不能为0");
         }catch (Exception e){
             System.out.println("Exception");
         }catch (Throwable t){//捕获多个异常要从小到大
             System.out.println("Throwable");
 ​
         }
 ​
         finally {
             System.out.println("finally");
         }
         //finally可以不要*/
 }
 ​

自定义异常

 package com.exception.demo02;
 ​
 public class MyException extends Exception{
     //传递数字
     private int detail;
 ​
     public MyException(int detail) {
 ​
         this.detail = detail;
     }
     //toString:异常的打印信息
     @Override
     public String toString() {
         return "MyException{" +
                 "detail=" + detail +
                 '}';
     }
 }
 package com.exception.demo02;
 ​
 public class Test {
     //可能会存在异常的方法
     static void test(int a) throws MyException {
         System.out.println("传递的参数为:"+a);
         if ( a>10 ){
             throw new MyException(a);
         }
         System.out.println("OK");
     }
 ​
     public static void main(String[] args) {
         try {
             test(11);
         } catch (MyException e) {
             System.out.println("MyException:"+e);
 ​
         }
     }
 }try-catch

合理使用

posted @ 2022-04-24 12:02  Unclesundada  阅读(20)  评论(0)    收藏  举报