目录
环境搭建和基础知识
什么是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);//输出a
System.out.println("b = "+b);//输出b
System.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.2f
double 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(); //标准输入一个整数赋值给a
System.out.println("请输入一个字符串");
str = scanner.nextLine();//多一个吸收回车换行符
str = scanner.nextLine();标准输入一个字符串赋值给str
System.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);//构造方法3
stu3.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) {//这是父构造方法 用this
this.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
相关函数 ----一般需要重写
package 继承demo4之Object;
class person{
String name;
int age;
String address;
}
class student extends person{//继承
public String toString() {
return "student:"+name +"," +age + ","+address;//返回字符串
}
/*@Override
public boolean equals(Object obj) {
// TODO Auto-generated method stub
return super.equals(obj);
}
*/
public boolean equals(person p) {//比较字符串
person s = (person)p;//强转这个类型
if(s.name == this.name &&s.address == this.address &&s.age == this.age)
return true;
else
return false;
}
}
public class Demo {
public static void main(String[] args) {
student s = new student();
s.name = "prppr";
s.age = 18;
s.address = "xiamen";
student p = new student();
p.name = "prppr";
p.age = 18;
p.address = "xiamen";
System.out.println(""+s.equals(p));//比较两个是否一样 类型strcmp
System.out.println(""+s.toString());//返回s的相关字符串
}
}
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();
else
return 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 stub
System.out.println("stm51 灯已打开");
}
void fnegShan() {
// TODO Auto-generated method stub
System.out.println("stm51 风扇已打开");
}
void lock() {
// TODO Auto-generated method stub
System.out.println("stm51 锁已打开");
}
void face() {
// TODO Auto-generated method stub
System.out.println("stm51 人脸识别已开启");
}
}
class c51con extends smaetHome{ //必须继承抽象方法补充完整
void Light() {
// TODO Auto-generated method stub
System.out.println("C51 灯已打开");
}
void fnegShan() {
// TODO Auto-generated method stub
System.out.println("C51 风扇已打开");
}
void lock() {
// TODO Auto-generated method stub
System.out.println("C51 锁已打开");
}
void face() {
// TODO Auto-generated method stub
System.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 { // 类实现接口 Action public void eat() { System.out.println("狗吃饭"); } public void drink() { System.out.println("狗喝水"); } }
package 继承抽象方法和接口;
interface Action{ //方法接口 注意关键字interface
void 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指向怎么一个类 调用这个类中的eat
new 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中内部类的printInfo
Demo1 dm = new Demo1(){
void printInfo() {
System.out.println("这不是Demo1 这是匿名内部类2");
}
};//得有分号
dm.printInfo();//实例化后调用Demo1中内部类的printInfo
new 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子类的实例 所以返回true
if(dog instanceof Animal) { //用于判断一个对象是否是另一个类的实例或者其子类的实例 成功返回true 错误返回false
System.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; //声明一个打印机的类 名字叫dayinji
public 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) { //如果该对象的年龄小于18
throw 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接收 或者Object
Student01<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 和name
this.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 继承01
Cls03<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());
}
}
泛型方法 ---- 方便好用
适用多次使用:同一个方法但类型不同时文章来源：https://www.toymoban.com/news/detail-677931.html
什么时候使用泛型方法： 当你想要在方法中灵活地接受和处理不同类型的参数时，而不涉及类中的其他方法，可以使用泛型方法
什么时候使用泛型类：当你需要创建一种数据结构或容器类能够处理多种类型的数据，并且这些类型是在实例化泛型类时确定的，可以使用泛型类。文章来源地址https://www.toymoban.com/news/detail-677931.html
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传过去 执行eat
dm1.printInfo2(new Cat());
dm1.printInfo2(new Animal());
Demo1.printInfo3(new Dog());//静态泛型方法
}
}
到了这里，关于01 java 学习 数据类型、基础语法、封装、继承、多态、接口、泛型、异常等的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！
