01 java 学习数据类型、基础语法、封装、继承、多态、接口、泛型、异常等

环境搭建和基础知识

什么是JRE:

什么是JDK:

基础数据类型

分支选择if else switch和c一毛一样

for和while循环还有数组基本和c一样

封装

函数调用、传参、命名规范、数组新命名规范

java输入Scanner scanner = new Scanner(System.in);

类的创建和使用以及封装修饰符

构造方法：含义、如何创建、如何使用

this：概念、使用方法

static 静态变量静态方法静态代码块

package包不同包如何使用

继承

java继承 extends xxx

java继承之 super和this类似，注意权限问题

java继承之方法重写

java继承之Object

java继承重写----小游戏

java继承小游戏 ----吃水果

抽象类和抽象方法 abstrac

外部类、内部类相互访问

抽象类和接口的----匿名内部类

多态之向上向下转型和 instanceof关键字

多态

继承----多态打印机

多态加强版

异常处理 try catch finally

手动捕获异常throw 和可能捕获异常throws

泛型

泛型 ---- 多个类别可使用Object Integer String等

泛型加强版 ---- 多个参数传递返回

泛型4大特性

泛型限定类型---- 限定参数类型、限定接口类型、限定类的类型 extends xxx

泛型通配符

泛型方法 ---- 方便好用

泛型类的方法约束和静态方法：

环境搭建和基础知识

下载网址：Eclipse Downloads | The Eclipse Foundation

什么是JRE:

Java的JRE（Java Runtime Environment）是Java平台上的运行时环境。它是Java应用程序运行所需的核心组件，包括Java虚拟机（JVM）、Java类库和其他必要的文件。

JRE提供了执行Java程序的基本功能，它负责解释和执行Java字节码。当你运行一个Java程序时，JRE会将字节码转换为机器码，并在计算机上执行。

除了Java虚拟机，JRE还包含了Java类库，这是一组预定义的类和方法，用于处理常见的任务，例如输入输出、图形用户界面、网络通信等。这些类库提供了丰富的功能，可以帮助开发者编写更加复杂和功能丰富的Java应用程序。

总而言之，JRE是Java应用程序运行所需的基本组件，它提供了Java虚拟机和类库，使得Java程序能够在不同的计算机上运行。

什么是JDK:

JDK是Java开发工具包，它是用于开发和编译Java应用程序的软件包。

JDK提供了Java开发所需的所有工具和资源，使开发者能够编写、编译和调试Java代码。它包含了Java编译器（javac）用于将源代码编译为Java字节码，

除了运行Java程序所需的组件，JDK还包含了Java标准库（Java Standard Library），这是一组预定义的类和方法，提供了许多常用功能的实现，例如字符串操作、文件和网络处理、集合框架等。开发者可以利用这些类库来加速开发过程，减少重复造轮子的工作。

总之，JDK是Java开发所需的基本工具包，它提供了编译器、虚拟机、开发工具和类库等组件，方便开发者进行Java应用程序的开发、编译和调试工作。

基础数据类型

package java第一个工程;public class Test {public static void main(String[] args) {System.out.print("hello ");System.out.print("world!!\n");System.out.println("hello world!!");//后面加ln的自动换行int a;a = 10;int b;b = 20;int c;c = a+b;System.out.println("a = "+a);//输出aSystem.out.println("b = "+b);//输出bSystem.out.println("a = "+a  + " b = "+b);//输出a b 用+连起来System.out.println("c = "+c);//输出c//a连上“+”连上b连上“=”连上c输出System.out.println(a + "+"+ b +"="+ c);//syso alt+/快捷指令float f = (float)0.2;//强转成float 或者0.2fdouble d = 0.3;System.out.println("f = "+f);System.out.println("d = "+d);}
}

分支选择if else switch和c一毛一样

package java第二个工程;//选择 if else switch和c语言一毛一样
public class Test {public static void main(String[] args) {int a = 1;if(a>0) {System.out.println("a是正整数");if(a == 100) {System.out.println("a等于"+a);}else {System.out.println(""+a + "不等于100");}}else {System.out.println("a是0或负整数");}switch(a) {case 1:System.out.println("a是1");break;case 2:System.out.println("a是2");break;case 3:System.out.println("a是3");break;case 100:System.out.println("a是100");break;}}
}

for和while循环还有数组基本和c一样

//循环
package java第三个工程;public class Test {public static void main(String[] args) {int i;for(i=0;i<10;i++) {System.out.println("yang lang good luclk!!");}	while(i != 0) {//不能直接while(i)System.out.println("杨浪很帅");i--;}}}//------------数组package java第四个工程;public class Test {public static void main(String[] args) {int arr[] = {1,2,3,4};System.out.println(arr[0]);System.out.println(arr[1]);System.out.println(arr[2]);System.out.println(arr[3]);int i;for(i=0;i<arr.length;i++) {System.out.println("arr数组的第"+i + "项" + "是" +  arr[i]);}int buff[] = new int[4];for(i=0;i<arr.length;i++) {buff[i] = i;System.out.println("buff数组的第"+i + "项" + "是" +  buff[i]);}int adds[] = null;for(i=0;i<adds.length;i++) {adds[i] = i;System.out.println("adds数组的第"+i + "项" + "是" +  adds[i]);}}
}

封装

函数调用、传参、命名规范、数组新命名规范

package java第五个工程;public class Test {static void add(int a, int b) {int c;c = a+b;System.out.println("这是加法 a+b="+c);}static void sub(int a, int b) {int c;c = a-b;System.out.println("这是减法 a-b="+c);}static void mul(int a, int b) {int c;c = a*b;System.out.println("这是乘法 a*b="+c);}static void div(int a, int b) {double c;c = a/b;System.out.println("这是除法 a/b="+c);}public static void main(String[] args) {int a = 4;int b = 3;add(a,b);//函数调用 加减乘除sub(a,b);mul(a,b);div(a,b);int[] socre = {12,15,65,55,33,44,89,20,15,57};//java数组命名规范int max;int min;max = min =socre[0];int i;for(i=0;i<socre.length;i++) {//找最大值和最小值if(max < socre[i]) {max = socre[i];}if(min > socre[i]) {min = socre[i];}}System.out.println("最大值max="+max);System.out.println("最小值min="+min);}}

java输入Scanner scanner = new Scanner(System.in);

package java第六个工厂;import java.util.Scanner;//引入包public class Test {public static void main(String[] args) {int a;String str;//定义一个字符串Scanner scanner = new Scanner(System.in);//创建一个新对象 且标准输入System.out.println("请输入一个整数");a = scanner.nextInt(); //标准输入一个整数赋值给aSystem.out.println("请输入一个字符串");str = scanner.nextLine();//多一个吸收回车换行符str = scanner.nextLine();标准输入一个字符串赋值给strSystem.out.println("a="+a);System.out.println("str="+str);float b;double c;b = scanner.nextFloat();c = scanner.nextDouble();System.out.println("b="+b + "c="+c);}
}

类的创建和使用以及封装修饰符

package pipDemo;//包//private（私有）:只有在同一个类中才可以访问私有成员（属性和方法）。----同包同子类
//默认  访问权限限制的作用范围与 private 相同，只能在同一个包同一个类中访问 ----同包不同子类
//protected（受保护）:只能从同一个包中或者继承该类的子类中访问受保护的成员（属性和方法）。--不同包同子类
//public（公共）:可以从任何地方访问公共成员（属性和方法），包括其他类和包。 --不同包不同子类import pipDemo.stu;//包里面的类class stu{//定义一个类String name;//行为private int age;//受保护的不可见 ---通过同同包同类成员才能改变和访问double score;private int num;//私有的  只有再同一个类中才能访问私有成员 属性和方法public void setNum(int a) {//公共的  可以从任何地方访问公共成员（属性和方法），包括其他类和包num = a;				//通过共用}private int changeage() {age = 18;return age;}int setage(int sureage) {//通过该函数查看age 但是又调用不可见changeage函数返回age return changeage();}void studentMsg() {//方法  函数System.out.println("num:"+num +  "name:"+name  + "age="+age +  "score="+score);}}public class Demo3 {public static void main(String[] args) {stu stu1 = new stu();//实例化申请内存stu1.name  = "prppr";//对该类赋值stu1.setage(66);//私有  同包同类stu1.score = 88.88;stu1.setNum(10);//私有stu1.studentMsg();}
}

构造方法：含义、如何创建、如何使用

含义：用于创建对象时初始化对象的状态。

如何创建：构造方法的名称必须与类名完全相同，并且没有返回类型（包括void）

如何使用：没有写则默认传入参数为空、使用构造方法创建对象并初始化属性

package 构造方法;class Student{String name;int age;double score;//构造方法1  没有写则默认 不传参数Student(){}//构造方法2  没有写则默认 不传参数Student(String newName,int newAge,double newScore){name = newName;age  = newAge;score= newScore;}//构造方法3  没有写则默认 不传参数Student(String newName,int newAge){name = newName;age  = newAge;}void setStudent() {System.out.println("name"+name + " age"+age);}
}
public class Demo01 {public static void main(String[] args) {Student stu1 = new Student();//构造方法1 stu1.name = "prppr";stu1.age  = 18;stu1.score= 98.886;System.out.println("name:"+stu1.name + " age:"+stu1.age +" score:"+stu1.score);Student stu2 = new Student("zhangsan",17,88.885);//构造方法2  使用构造方法创建对象并初始化属性System.out.println("name:"+stu2.name + " age:"+stu2.age +" score:"+stu2.score);Student stu3 = new Student("lisi",16);//构造方法3stu3.setStudent();}
}

this：概念、使用方法

概念：关键字this用于引用当前对象。它可以在类的成员方法、构造方法和代码块中使用

使用方法：1.在成员方法中使用this 如this.name this.setStudent();
2.在构造方法中使用this 必须将this作为第一条语句，并传递参数，因为初始化
3.在主函数代码块中使用this

package this使用方法;class Studet{String name;int age;//构造方法一Studet(){//在构造方法的内部调用其他构造方法，那么这个调用语句必须作为构造方法的第一条语句，//因为构造方法的目的是初始化对象的状态。this("prppr",24);//使用构造方法二System.out.println("这是构造方法一");}//构造方法二Studet(String name,int age){System.out.println("这是构造方法二");this.name = name;this.age  = age;}void setStudent() {System.out.println("这是setStudent");System.out.println("name:"+this.name + " age:"+this.age);}
}
public class Demo01 {//使用构造方法一传参数给构造方法二初始化stu1 并通过setStudent打印public static void main(String[] args) {Studet stu1 = new Studet();//使用构造方法一开辟空间 且不传参数stu1.setStudent();}
}

static 静态变量静态方法静态代码块

静态变量：通过类名直接访问静态变量可通过静态代码块对其初始化
静态方法：通过类名直接访问静态方法只能访问静态变量等内容
静态代码块：只要初始化实例便会执行静态代码块最先执行，且只执行一次

package static使用方法;
class Student{String  name;private int age;//只能通过私有方法才能使用该变量double score;static int data;//静态变量static void staticStudent() {System.out.println("这是静态方法");//静态方法 且只能访问静态内容 且不能有this}static {data = 100;//静态代码块初始化静态变量System.err.println("这是静态代码块");//静态代码块}Student(String name,int age,double score){	//构造方法this.name = name;this.age  = age;this.score= score;}	void outputStudent() {System.out.println("构造方法：name"+name + " age"+age + " score"+score);}
}public class Demo01 {public static void main(String[] args) {Student stu1 = new Student("YangLang",18,66.66);//构造方法stu1.outputStudent();System.out.println("静态变量"+Student.data);//静态变量 直接类名可以调用Student.staticStudent();					//静态方法 直接类名可以调用//在构造方法初始化时 静态代码块在类加载时执行，并且只执行一次 最先执行}
}

package包不同包如何使用

1. 导入包 2.访问权限是否同一个包下 3.创建对象实例化 4.使用类成员

package com.prppr.leren;
import com.prppr.usr.DemoNew;//shift ctrl o
//import com.prppr.usr.Demo; // 导入com.prppr.usr包中的Demo类
//import com.prppr.leren.*; // 导入com.prppr.leren包中的所有类public class Test {public static void main(String[] args) {Demo dm1 = new Demo();//实例化//com.prppr.usr.Demo dm = new com.prppr.usr.Demo();dm1.age = 18;dm1.outPut();DemoNew dm2 = new DemoNew();//实例化  不同包 不同封装修饰符 public//访问权限：被访问的类和成员需要设置合适的访问修饰符dm2.name = "prppr";dm2.outPutName();}
}

继承

java继承 extends xxx

概念：1.基于已存在的类来创建新类 2.重用已存在的方法和属性也可以添加新的方法属性 3.旧的是父类新的是子类 4.除Object外都是子类都只有一个父类。

如何创建：用exrends关键字

//import com.prppr.jicheng; import用于导入其他类供当前代码使用
package com.prppr.jicheng; //package用于指定当前代码中的类所属的包 放在第一句class Person{String name;int age;public void eat() {System.out.println("人吃饭");}public void pringInfo() {System.out.println("name:"+name);}
}class Student extends Person{//extends Person继承前面属性 即拷贝相同属性的部分public void StudentBeat() {System.out.println("Student:读书");}
}public class Test{public static void main(String[] args) {Person p = new Person();p.name = "prppr";p.age  = 18;System.out.println("person:"+p.name + +p.age);Student s = new Student();s.name = "xiaoming";//已经继承s.age  = 13;		//已经继承System.out.println("Student:"+s.name + +s.age);s.pringInfo();}
}

java继承之 super和this类似，注意权限问题

方法:使用super关键字可以在子类中访问父类的成员变量。通过super.变量名的方式

package 继承demo2之super关键字;class Person{String name;int age;String address;private String action;//私有地址属性  ---- 通过私有方法actionPerform才可以调用void eat() {System.out.println("人吃饭");}public Person(String name,int age,String address) {//这是父构造方法 用thisthis.name = name;this.age = age;this.address = address;System.out.println("这是父类构造方法:"+this.name + this.age + ","+this.address);}public void actionPerform() {//公有方法 中去调用同类中的私有变量  action  = "papa";System.out.println("action:"+action);}Person(){	//若子类没有传参数 防止继承冲突 需要构造一个没有参数的构造方法}
}class Student extends Person{void StudenBeat() {System.out.println("学生读书");}Student(){//子类构造方法  用super先初始化父类构造方法super("yanglang",18,"xiamen");	//初始化并调用父类构造方法System.out.println("这是子类构造方法");StudenBeat();System.out.println("学生:"+super.name + super.age + ""+super.address);//继承父类信息  或者自己用s.name = "xx"}
}public class Demo {public static void main(String[] args) {Student s = new Student();//子类 构造方法/*s.name = "prprp";//继承父类属性  自己赋值 也可以全部拷贝父类s.age  = 18;s.address = "上海";System.out.println("Student:"+s.name + ","+s.age + ","+s.address);*/s.actionPerform();}
}

java继承之方法重写

概念：方法重写（Method Overriding）是指在子类中重新实现（覆盖）继承自父类的方法

重写方法的特点如下：

方法名称、参数列表和返回类型需要与父类的方法一致。
子类重写的方法不能比父类中被重写的方法更严格地限制访问修饰符的可见性。
子类不能重写父类中被声明为final的方法。
子类不能重写父类中被声明为static的方法，但可以进行方法的隐藏（Hiding）。
子类重写方法可以抛出与被重写方法相同的异常，或者父类方法声明异常类型的子类型。

package 继承demo3之方法重写;class person{String name;int age;public void printInfo() {				System.out.println("这是父类打印");}
}class student extends person{			//子类的方法拥有与父类方法相同的方法名、参数列表和返回类型public void printInfo() {							 //重写  等级不能比父类等级更严格super.printInfo();								 //调用父类System.out.println("这是子类打印:"+name + ""+age);//}
}public class Demo {public static void main(String[] args) {student s = new student();s.name = "prppr";s.age  = 19;s.printInfo();}
}

java继承之Object

java继承重写----小游戏

package 吃鸡小游戏;class WuQi{String name;void gongji() {System.out.println("武器攻击");}
}class K98 extends WuQi{void gongji() {System.out.println("98K攻击");}
}class KouShui extends WuQi{void gongji() {System.out.println("口水攻击");}
}class WanJia{String name;String duanWei;int id;WuQi wuqi;//调用武器void action() {System.out.println("玩家攻击,"+name + ","+duanWei + ","+id);wuqi.gongji();}
}
public class ChiJi {public static void main(String[] args) {WanJia wj = new WanJia();wj.name   = "玩家一";wj.duanWei= "王者";wj.id     = 66666;wj.wuqi = new WuQi();//wanjia的wuqi 指向WuQi这个类wj.action();		 //调用action输出打印wj.wuqi = new KouShui();//wanjia的wuqi 指向KouShui这个类--因为继承了武器的属性方法 并重写方法wj.action();wj.wuqi = new K98();//wanjia的wuqi 指向K98这个类--因为继承了武器的属性方法 并重写方法wj.action();}
}

java继承小游戏 ----吃水果

package 继承吃水果;
class fruitsMsg{  			//水果类  苹果 橙子继承并重写水果String name;void printInfo() {System.out.println("爱吃水果");}
}class Apple extends fruitsMsg{String name;void printInfo() {System.out.println("爱吃苹果");}
}class orange extends fruitsMsg{String name;void printInfo() {System.out.println("爱吃橙子");}
}class getFruits{			//通过这个类里面的函数 如果名字是xx则返回这个类 实例化static fruitsMsg getFruitsName(String name) {//返回值是水果类型 苹果橙子继承if(name == "apple")return new Apple(); //类 实例化加括号else if(name == "orange")return new orange();elsereturn null;}}public class Fruits{public static void main(String[] args) {getFruits.getFruitsName("apple").printInfo();//通过这个函数传过去名字返回类实例化  调用里面的printInfo打印getFruits.getFruitsName("orange").printInfo();}}

抽象类和抽象方法 abstrac

概念：方法中什么都没有写-----就是抽象方法含有抽象方法----就是抽象类
抽象类加abstract是抽象类方法不含abxtract则不是抽象方法

抽象方法特点：1.只有抽象头不含抽象体， 2.用sbstract来修饰
3.是一种不确定的方法行为 4.抽象方法不能被调用 5. 抽象类不能直接被调用

package 抽象类抽象方法02;
abstract class smaetHome{		//抽象类abstract void Light();		//抽象方法  不能直接调用 通过子类完善 调用子类继承父类abstract void fnegShan();abstract void lock();abstract void face();void printInfo() {Light();fnegShan();lock();face();}
}
class stm51com extends smaetHome{void Light() {// TODO Auto-generated method stubSystem.out.println("stm51 灯已打开");}void fnegShan() {// TODO Auto-generated method stubSystem.out.println("stm51 风扇已打开");}void lock() {// TODO Auto-generated method stubSystem.out.println("stm51 锁已打开");}void face() {// TODO Auto-generated method stubSystem.out.println("stm51 人脸识别已开启");}
}
class c51con extends smaetHome{ //必须继承抽象方法补充完整void Light() {// TODO Auto-generated method stubSystem.out.println("C51 灯已打开");}void fnegShan() {// TODO Auto-generated method stubSystem.out.println("C51 风扇已打开");}void lock() {// TODO Auto-generated method stubSystem.out.println("C51 锁已打开");}void face() {// TODO Auto-generated method stubSystem.out.println("C51 人脸识别已开启");}
}public class Test {public static void main(String[] args) {c51con c51 = new c51con();		//通过继承 c51实例化 把抽象类中的抽象方法补充完整 后调用打印c51.printInfo();stm51com stm51 = new  stm51com();stm51.printInfo();}
}

类似抽象类方法----接口

使用关键字 interface implements

interface Action { // 方法接口void eat();void drink();
}class Dog implements Action { // 类实现接口 Actionpublic void eat() {System.out.println("狗吃饭");}public void drink() {System.out.println("狗喝水");}
}

package 继承抽象方法和接口;interface Action{ //方法接口      注意关键字interfacevoid eat();void drink();
}class Dog implements Action{	// 用implements调用接口 填充方法public void eat() {System.out.println("够吃屎");}public void drink() {System.out.println("狗喝屁");}
}class Person implements Action{// 用implements调用接口 填充方法public void eat() {System.out.println("人吃饭");}public void drink() {System.out.println("人喝水");}
}
public class Test {public static void main(String[] args) {new Dog().eat(); //new Dog指向怎么一个类 调用这个类中的eatnew Person().eat();}
}

外部类、内部类相互访问

package 外部类和内部类;class outer{		//外部类int data;void printData() {System.out.println("这是外部类 data="+this.data);}void lookInner() { //调用o.lookInner 通过外部类访问内部类inner i = new inner();i.data = 588;System.out.println("通过外内类 访问内部类 data"+data);}class inner{		//内部类int data;void printInnerData() {System.out.println("这是内部类输出 data="+data);outer.this.printData();			//通过内部类访问外部类}}}
public class Test {public static void main(String[] args) {outer o = new outer();	//实例化外部类outer.inner i = o.new inner();//实例化内部类o.data  = 100;i.data  = 500;o.lookInner();  //通过外部类访问内部类i.printInnerData();内部类调用外部类}
}

抽象类和接口的----匿名内部类

package 匿名内部类01;
abstract class Demo1{			//抽象类abstract void printInfo();  //抽象方法
}interface Demo2{		//接口void printfMsg();
}public class Test {public static void main(String[] args) {new Demo1(){	//是Demo1中的匿名内部类void printInfo() {System.out.println("这不是Demo1 这是匿名内部类1");}}.printInfo();//实例化后调用Demo1中内部类的printInfoDemo1 dm = new Demo1(){void printInfo() {System.out.println("这不是Demo1 这是匿名内部类2");}};//得有分号dm.printInfo();//实例化后调用Demo1中内部类的printInfonew Demo2() {			//生成接口内部类并实例化public void printfMsg() {		//权限级别不能比接口或者父类的低System.out.println("这是接口匿名内部类 1 ");}}.printfMsg();;Demo2 dm2 = new Demo2() {public void printfMsg() {		//权限级别不能比接口或者父类的低System.out.println("这是接口匿名内部类 2 ");}};dm2.printfMsg();}
}

多态之向上向下转型和 instanceof关键字

package 多态之上下转型和关键字instanceof;
abstract class Animal{String name;abstract void  eat();
}class Dog extends Animal{void eat(){System.out.println("狗吃屎 "+name);}void sleep() {System.out.println("狗狗睡觉");}
}class Cat extends Animal{void eat() {System.out.println("猫吃鱼 "+name);}
}public class Test {public static void main(String[] args) {Animal dog = new Dog(); //把dog实例化 向上转型成Animal  会把Animal中没有的过滤掉 如dog.sleep()错误dog.name = "旺财";		//相当于	Animal dog =(Animal) new Dog();dog.eat();Animal cat = new Cat();cat.name = "Tom";cat.eat();Dog dog2 = new Dog();	//dog实例化 向下转型 Dog中所有元素都可以执行dog2.name = "啊黄";dog2.eat();dog2.sleep();//dog是Dog的实例 也Animal子类的实例  所以返回trueif(dog instanceof Animal) { //用于判断一个对象是否是另一个类的实例或者其子类的实例 成功返回true 错误返回falseSystem.out.println("两个实例化一样");}}
}

多态

继承----多态打印机

package 多态打印机;
//实例化学校和彩色 黑白 打印机class School{		//学校类 类中声明了继承打印机的彩色和黑白打印CaiSeDayin   cy;//类中声明了继承打印机的彩色和黑白打印 HeiBaiDayin  hb;//类中声明了继承打印机的彩色和黑白打印void anZhuangCaiSeDayin(CaiSeDayin   cy) {//学校类里面安装 方法 并把打印机参数传过去System.out.println("安装成功");cy.print("彩色");//调用彩色打印中的方法}void anZhuangHeiBaiDayin(HeiBaiDayin  hb) {学校类里面安装 方法 并把打印机参数传过去System.out.println("安装成功");hb.print("黑白");//调用黑白打印中的方法}
}class Dayin{	//打印类 继承彩色和黑白public String PinPai;public void print(String msg) {}
}class CaiSeDayin extends Dayin{public void print(String msg) {System.out.println("彩色打印"+msg);}
}class HeiBaiDayin extends Dayin{public void print(String msg) {System.out.println("黑白打印"+msg);}
}
public class Test {public static void main(String[] args) {School s = new School();//实例化学校CaiSeDayin c = new CaiSeDayin();//实例化彩色打印s.anZhuangCaiSeDayin(c);HeiBaiDayin h = new HeiBaiDayin();//实例化黑白打印机s.anZhuangHeiBaiDayin(h);}
}

多态加强版

package 多态打印机02;
//实例化学校和彩色 黑白 打印机
class School{    //学校类Dayin dayinji;  //声明一个打印机的类 名字叫dayinjipublic void anZhuangDayin(Dayin dayinji) {//通过s.anzhuang 把各种打印机传过来 因为是继承打印机的System.out.println("安装成功");this.dayinji = dayinji;//把传过来的各种打印机子类 赋值给父类打印机Dayin}public void print(String msg) {//通过s.print传入参数填充到 传过来付给Dayinji中输出dayinji.print(msg);}
}class Dayin{	//打印类 继承彩色和黑白public String PinPai;public void print(String msg) {}
}class CaiSeDayin extends Dayin{public void print(String msg) {System.out.println("彩色打印"+msg);}
}class HeiBaiDayin extends Dayin{public void print(String msg) {System.out.println("黑白打印"+msg);}
}class ZhenDayin extends Dayin{public void print(String msg) {System.out.println("真是打印"+msg);}
}
public class Test {public static void main(String[] args) {School s = new School();//实例化学校CaiSeDayin c = new CaiSeDayin();//实例化彩色打印s.anZhuangDayin(c);s.print("prppr");HeiBaiDayin h = new HeiBaiDayin();//实例化黑白打印机s.anZhuangDayin(h);s.print("杨浪");ZhenDayin z = new ZhenDayin();//实例化真是打印机s.anZhuangDayin(z);s.print("水良");}
}

异常处理 try catch finally

Unchecked异常不需要在代码中显式地捕获或处理，编译器也不会强制要求处理。常见的Unchecked异常包括NullPointerException、ArrayIndexOutOfBoundsException等。

可以使用try-catch语句来捕获和处理异常。try块中放置可能会抛出异常的代码，catch块中处理异常情况。还可以使用finally块在无论是否发生异常都会执行的代码。

package 异常try_catch_finally;import java.security.DrbgParameters.NextBytes;
import java.util.Scanner;class GoWork{public void printWork() {System.out.println("上班~~~");}
}public class Test {public static void main(String[] args) {Scanner scanner = new Scanner(System.in);//引入输入api的包GoWork g = null;int a = 10;double b = 0;double  c = 0;try {System.out.println("请输入b");b = scanner.nextDouble();if (b == 0) {throw new ArithmeticException("除数不能为0");}c = a/b;System.out.println("c="+c);g.printWork();}catch (Exception  e) {					//捕获所有异常  不能和别的异常同时存在System.out.println("捕获所有异常");}/*catch (java.lang.NullPointerException e) {//捕获空指针异常System.out.println("这是空指针异常");}catch (java.lang.ArithmeticException e) {//捕获数学异常System.out.println("输入的除数不能为0 请重新输入");b = scanner.nextDouble();if (b == 0) {throw new ArithmeticException("除数不能为0");}c = a/b;System.out.println("c="+c);}*/finally {								//不论是否异常都会执行该语句System.out.println("end!!");}System.out.println("end!!");System.out.println("end!!");System.out.println("end!!");}
}

手动捕获异常throw 和可能捕获异常throws

package 异常手动抛出异常throw可能异常throws;import javax.net.ssl.ExtendedSSLSession;class Club{int age;public Club(int age) {		//构造方法实例化 传过来年龄this.age = age;			//赋值给该对象的age}public void printInfo() throws ageLess18{//可能出现这个异常if(age < 18) {			//如果该对象的年龄小于18throw new ageLess18("年龄太小 不符合规定");//年龄小于十八 throw手动抛出异常}}
}class ageLess18  extends Exception{	//自己封装的一个捕获异常的类 继承与所有异常private String msg;public ageLess18(String msg) {	this.msg = msg;}
}public class Test {public static void main(String[] args) {Club c = new Club(16);try {//try块中放置可能会抛出异常的代码c.printInfo();}catch(ageLess18 b) {//catch块中处理异常情况 如果是这个异常就执行一下内容b.printStackTrace();System.out.println("捕获:"+b.getMessage());}finally { //finally块在无论是否发生异常都会执行的代码。System.out.println("end");}}
}

泛型

泛型 ---- 多个类别可使用Object <T> Integer String等

参数化类型来增强代码的类型安全性和可读性，减少了类型转换的繁琐和容易出错的问题。

package 泛型demo01;
class Student01<T>{		//T表示传过来的类型T age;					//Object自动匹配传过来的类型 可以是整型数字符串
//	Integer  a = 10;			//Integer 是一个包装类，它提供了一些便利的方法来处理整数Student01(T  age) {System.out.println("age:"+age);this.age = age;}public T   printInfo() {return age;}
}//class Student02{
//	String age;
//	Student02(String age) {
//		System.out.println("age:"+age);
//		this.age = age;
//	}
//	
//	public String printInfo() {
//		return age;
//	}
//}
public class Test {public static void main(String[] args) {//<Integer> 表示传过去的是int类型 Student01中用T接收  或者ObjectStudent01<Integer> s1 = new Student01<Integer>(18);	System.out.println(s1.printInfo());Student01<String> s2 = new Student01<String>("prppr");System.out.println(s2.printInfo());}
}

泛型加强版 ---- 多个参数传递返回

反类型特点：1.泛型类参数可以是泛型类、2.泛型类可设置多个泛型参数、3.泛型类可以继承泛型类、4.泛型类可以实现泛型接口

package 泛型多个传入类型demo02;class Student<T>{ //第一个类 来一个T类型参数T age;Student(T age){this.age = age;}public T printInfo() {return age;}
}class Student02<T1,T2>{//传过来两个参数 参数一是T1类型 参数二是T2类型T1 age;T2 name;Student02(T1 age,T2 name){//传过来的这个类型参数赋值给this这个类的age 和namethis.age = age;this.name = name;}public T1 printAge() {return age;}public T2 printName() {return name;}
}public class Test {public static void main(String[] args) {//传过去一个整型类型Student<Integer>  s1 = new Student<Integer> (18);System.out.println(s1.printInfo());//传过去一个字符串类型Student<String>  s2 = new Student<String> ("水良");System.out.println(s2.printInfo());//传过去两个不同类型参数Student02<Integer,String>  s3 = new Student02<Integer,String> (24,"水良"); System.out.println(s3.printAge() + s3.printName());	//不同类型是 + 是连起来//传过去两个相同类型参数Student02<Integer,Integer>  s4 = new Student02<Integer,Integer> (24,34); System.out.println(s4.printAge() + s4.printName()); //同类型 返回结果是加起来 不是连起来//sum接收把两个返回值加起来 输出int sum = 0;		sum = s4.printAge() + s4.printName();System.out.println(sum);}
}

泛型4大特性

package 泛型类四大特性demo03;class Cls01<T>{T data;public Cls01(T data) {this.data = data;}public T printInfo() {return data;}
}class Cls02<T1,T2>{T1 data;T2 name; Cls02(T1 data,T2 name) {this.data = data;this.name  = name;}public T1 printInfo1() {return data;}public T2 printInfo2() {return name;}
}interface ClsJieKou<T3>{//接口 abstract void printMsg(T3 msg);//抽象方法 需重写
}class Cls03<T2,T3> extends Cls01  implements ClsJieKou<T3>{T2 name; Cls03(T2 name) {super(200);		//泛型类继承泛型类this.name  = name;}public T2 printInfo2() {return name;}public void printMsg(T3 msg) {System.out.println("这是泛型类实现泛型接口"+msg);}
}public class Test {public static void main(String[] args) {Cls01<Integer>  c1 = new Cls01<Integer> (18);//构造方法 泛型传过去一个整型数System.out.println(c1.printInfo());Cls01<String>  c2 = new Cls01<String> ("prppr");//构造方法 泛型传过去一个字符串System.out.println(c2.printInfo());//构造方法 传过去一个泛型类Cls01<Integer>     		  对传过去的泛型类实例化并传参数Cls01<Cls01<Integer>> c3 = new Cls01<Cls01<Integer>> (new Cls01<Integer> (28));//				   c3.printInfo是获取到泛型类再.printInfo获取到里面内容System.out.println(c3.printInfo().printInfo());//泛型类传递多个参数 两个三个多个Cls02<Integer,String> c4 = new Cls02<Integer,String> (100,"水良");System.out.println(c4.printInfo1() + c4.printInfo2());//泛型类继承泛型类03 继承01Cls03<String,String> c5 = new Cls03<String,String> ("这是c5  Cls03 继承Cls01");System.out.println(c5.printInfo() + c5.printInfo2());  //c5.printInfo是父类方法//泛型类继承泛型类 且继承接口Cls03<String,String> c6 = new Cls03<String,String> ("这是c6  c6继承c1 且继承接口泛型类");System.out.println(c6.printInfo() + c6.printInfo2());  //c5.printInfo是父类方法c6.printMsg("msg接口");}
}

泛型限定类型---- 限定参数类型、限定接口类型、限定类的类型 extends xxx

import java.util.List;public class GenericExample<T extends Number> {private T value;public void setValue(T value) {this.value = value;}public T getValue() {return value;}/*** 使用限定通配符来限定列表中的元素类型必须是 Number 或其子类，* 计算并返回列表中所有数值的总和。** @param numbers 限定通配符，表示列表中元素类型必须是 Number 或其子类* @return 计算得到的数值总和*/public double sum(List<? extends Number> numbers) {double sum = 0;for (Number number : numbers) {sum += number.doubleValue();}return sum;}public static void main(String[] args) {GenericExample<Integer> example = new GenericExample<>();example.setValue(10);Integer value = example.getValue();// 限定通配符，方法参数类型必须是 Number 或其子类List<Integer> integerList = List.of(1, 2, 3);double result = example.sum(integerList);System.out.println("Value: " + value);System.out.println("Sum: " + result);}
}

泛型通配符 <?>

1.统配数据类型、2.统配类、用extends 匹配上界 super匹配下界

package 泛型通配符_上界extends_下界super;class cls01<T>{T data;cls01(T data) {this.data = data;}public T printInfo() {return data;}
}class Animal{}
class Dog extends Animal{ //Dog继承Animal}public class Test {public static void main(String[] args) {cls01<Integer>  c1 = new cls01<Integer> (18);//构造方法 实例化System.out.println(c1.printInfo());cls01<String>  c2 = new cls01<String> ("prppr");//构造方法 实例化System.out.println(c2.printInfo());//			 	c1 = c2;  报错 类型不一样cls01<?>  c3 = new cls01<> ("prppr");//利用通配符 构造方法 实例化System.out.println(c3.printInfo());cls01<?>  c4; //通配符 匹配整型数、匹配字符串c4 = c1;	  c4 = c2;cls01<? extends Animal>  c5;	//统配Animal上界cls01<Dog>  c6 = new cls01<Dog> (new Dog());//构造方法 实例化System.out.println(c6.printInfo());/*由于无界通配符无法确定具体的类型范围，而 printInfo() 方法返回的是通配符 ? 的类型，没有重写其父类 Object 的 toString() 方法，因此编译器会默认调用父类的 toString() 方法，它返回的是对象的哈希码。*/cls01<? super Dog>  c7;	//统配Animal下界cls01<Dog>  c8 = new cls01<Dog> (new Dog());//构造方法 实例化System.out.println(c8.printInfo());}
}

泛型方法 ---- 方便好用

适用多次使用:同一个方法但类型不同时

什么时候使用泛型方法：当你想要在方法中灵活地接受和处理不同类型的参数时，而不涉及类中的其他方法，可以使用泛型方法
什么时候使用泛型类：当你需要创建一种数据结构或容器类能够处理多种类型的数据，并且这些类型是在实例化泛型类时确定的，可以使用泛型类。

package 泛型方法;
class Demo1{
//	T data;
//	Demo1(T data){
//		System.out.println("这是构造方法"+data);
//	}public <T1 ,T2 > void printInfo(T1 data,T2 name) {//泛型方法 多个类型传递System.out.println("这是泛型方法:data"+data + ",name"+name);}}
public class Test {public static void main(String[] args) {
//				Demo1<String> dm1 = new Demo1<String> ("prppr"); //泛型类 构造方法Demo1 dm2 = new Demo1();//构造方法dm2.printInfo(24,"水良");//泛型构造方法dm2.printInfo(123,45);
//				dm2.printInfo(66.666); 泛型方法 传递单个参数 在类中的方法T会自动匹配
//				dm2.printInfo('c');}
}

泛型类的方法约束和静态方法：

package 泛型方法约束和静态泛型方法;
class Demo1{public <T> void printInfo(T data) {System.out.println("这是泛型方法:"+data);}//传过来一个动物的子类 并调用这个动物子类的eat行为public <T extends Animal> void printInfo2(T whos) {whos.eat();}public static <T extends Animal> void printInfo3(T whos) {whos.eat();}
}class Animal{public void eat() {System.out.println("动物吃东西");}
}class Dog extends Animal{   //传递的是继承Animal的类public void eat() {System.out.println("gou吃东西");}
}class Cat extends Animal{   //传递的是继承Animal的类public void eat() {System.out.println("mao吃东西");}
}
public class Test {public static void main(String[] args) {Demo1 dm1 = new Demo1();dm1.printInfo("prppr");//可以传递不同类型参数Animal an1 = new Animal();//实例化dm1.printInfo2(new Dog());//把Dog继承与Animal传过去 执行eatdm1.printInfo2(new Cat());dm1.printInfo2(new Animal());Demo1.printInfo3(new Dog());//静态泛型方法}
}