封装，继承，多态和异常

封装

封装是将该类的数据等信息封装在一起，数据就会具有安全性，而且期间的运行过程也不会被看到，并且提高了复用性。

private关键字

权限修饰符，修饰成员变量和成员方法

该数据只能在本类中使用

（public都能使用，默认同一个包内可以访问 ，protected同包里面的类和其他子类）

建立setXXX（参数）/getXXX（）进行变量的相关操作。

this关键字

区别成员变量和局部变量（this的本质：代表方法调用者的地址值）

构造方法

作用：创建对象的时候，由虚拟机调用，对变量进行初始化

分类：无参构造：初始化，默认值

有参构造：初始化的同时，进行赋值

任何类定义出来，就带有无参构造，但是写上有参构造时，无参构造会消失，所以有参无参都写上去。

标准的Javabean类

类名见名知意；成员变量被private修饰；两个构造方法（有参无参）；每一个变量都有getXX/setXX方法；有其他行为也要加上。

public class goods {
    private String id;
    private String name;
    private double price;
    private int count;
    public goods(){
    }
public goods(String id, String name, double price, int count) {
    this.id = id;
    this.name = name;
    this.price = price;
    this.count = count;
}

public String getId() {
    return id;
}

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

public String getName() {
    return name;
}

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

public double getPrice() {
    return price;
}

public void setPrice(double price) {
    this.price = price;
}

public int getCount() {
    return count;
}

public void setCount(int count) {
    this.count = count;
}

}

练习

文字版格斗游戏；数组（输入next/nextInt…和nextline的区别），暂时建议使用前者，不容易出现问题。

文字版格斗游戏部分代码：

public class Gametest {
    public static void main(String[] args) {
        Role r1=new Role("qiao",100,'男');
        Role r2=new Role("xiao",100,'女');
        r1.showRole();
        r2.showRole();
        while(true){
            r1.attack(r2);
            if(r2.getBlood()==0){
                System.out.println(r2.getName()+"死了");
                break;
            }
            r2.attack(r1);
            if(r1.getBlood()==0){
             System.out.println(r1.getName()+"死了");
               break;
           }
        }
    }
}

String

概述

两个字符串，之后再合并，其实创造了三个空间。

String其实是java定义好的一个类，在java.lang包之中，使用时不需要导包，所有的字符串文字都被实为此类的对象。
学习内容：
创建字符串对象
字符串内存分布
字符串比较（equals…方法）

API和API帮助文档

集合

（增删改查）

static关键字

静态变量：属于类；被所有对象共享，随着类加载而加载，优于对象存在；

静态方法：多在测试类和工具类当中；只能访问静态变量和静态方法；没有this关键字。

非静态方法可以访问所有。

练习：

public class Student {
    String name;
    int age;
    static String teacherName;
    public void show1(){
        System.out.println("this:"+this);
        System.out.println(name+" "+age+" "+teacherName);
    }
    public static void method(){
        System.out.println("静态变量");
    }
}

继承

Java只能单继承，不能多继承，可以多层继承，所有的类直接或者间接继承于object类。

子类只能访问父类中的非私有成员。

继承练习：使用画图法，从下往上，提取共性。（书写代码：从上往下）

​​​​

父类的构造方法：子类均不能继承；成员变量均可以继承（但不一定可以调用private）

成员方法：非私有的（虚方法表中的）可以继承。（寻找方法时从顶级，创建虚方法表：非private，非static，非final），一级一级添加，性能提高。（object有五个虚方法）

拓展补充：Java中的内存分析工具。

语法特点

成员变量的访问方法：就近原则（super表示父类）

public class Test {
    public static void main(String[] args) {
        Zi zi=new Zi();
        zi.ziShow();
    }
}
class Fu{
    String name="Fu";
}
class Zi extends Fu{
    String name="zi";
    public void ziShow(){
        String name="zishow";
        System.out.println(name);
        System.out.println(this.name);
        System.out.println(super.name);
    }
}

​​

多态

多态其实就是同一个方法名可以根据不同的对象调用不同的实现。
在Java中，多态可以通过继承和接口实现。当子类继承了父类，它不仅可以使用父类中的方法，还可以重写父类的方法，提供自己的实现。此时，当使用父类类型的引用指向子类对象时，就可以根据不同的对象调用不同的实现。

优势

1.提高代码的灵活性和可扩展性
2.降低耦合度
3.提高代码的可读性和可维护性

弊端

1.运行效率有所下降
2.难以调试
3.安全性问题

public class Animal {
    public void makeSound() {
        System.out.println("Animal is making sound.");
    }
}
public class Dog extends Animal {

@Override

public void makeSound() {

System.out.println("Dog is barking.");

}

}


public class Cat extends Animal {

@Override

public void makeSound() {

System.out.println("Cat is meowing.");

}

}


public class Main {

public static void main(String[] args) {

Animal animal1 = new Dog();

Animal animal2 = new Cat();


    animal1.makeSound(); 
    animal2.makeSound(); 
}

}

异常

定义

异常是运行程序的过程中产生的异常情况。

所有的异常类型都是内置类java.lang.Throwable的子类，超类Throwable下面由两个子类error和Exception。

异常处理的方式

try…catch:

try指尝试执行可能出现异常的代码，如果没出现异常，那么不执行catch语句，否则通过catch捕捉异常，然后处理异常。（try和catch必须同时出现，一个try可以多个catch）

throw和throws：

自定义异常类

使用异常类步骤：
1.创建自定义异常类
2.在方法中通过throw关键字抛出异常对象
3.如果在当前抛出异常的方法中处理异常，可以使用try-catch语句捕获并处理；否则在方法的声明处通过throws关键字指明要抛出给方法调用者的异常，继续进行下一次操作
4.在出现异常方法的调用者中捕获并处理异常

常见的异常类

算术异常类：ArithmeticExecption
空指针异常类：NullPointerException
类型强制转换异常：ClassCastException
数组负下标异常：NegativeArrayException

public class Main {
    public static void main(String[] args) {
        try {
            int a = 10;
            int b = 0;
            int result = a / b;
            System.out.println(result);
        } catch (ArithmeticException e) {
            System.out.println("发生了算术异常：" + e.getMessage());
        }
    }
}