目录
成员变量初始值
Object
equals和==
toString()方法
instanceof关键字
内存分析
参数传递问题
内部类
成员内部类
局部内部类
匿名内部类
匿名内部类在将开发中的使用
异常处理
异常的分类
异常处理的语法句子
抛异常处理throws和throw【少用为妙】
成员变量初始值
java中的变量必须先声明，后赋值才能使用。java中的成员变量，在创建对象的时候，都会执行一次初始化操作，都会给一个默认值。
public class Test {public static void main(String[] args) {// int n;// System.out.println(n);//会报错：可能尚未初始化变量n}}
byte b;//byte=0short s;//short=0int i;//int=0long l;//long=0float f;//float=0.0double d;//double=0.0char c;//char= //注意这里是有一个空格的//System.out.println("char="+(int)p.c);//强转成int型-->0boolean bool;//boolean=falseString str;// String是Java提供的一个类//String=nullChild child;//自己写的类Child的默认值//Child=null
Object
万事万物皆为对象所有的东西都是对象在Java中所有的类都要继承objectobject是一个类，所有类的根我们的写的类即使不写继承关系，那么默认也会继承object【创建一个Person class但是里面什么都不写】【Student会继承Person类同时也会继承object类，因为object是一个类，所有类的根】
public class Student extends Person{public static void main(String[] args) {Student s=new Student();//s.//默认也会继承object}}
equals和==
equals和====判断左右两端的数据是否一致equals：object类提供的一个方法，用来判断两个对象是否相等【这里的相等并非一般情况的相等两只猫的颜色一样可以称为相等两只猫的中重量相等也可以成为相等】equals可以自己重写字符串的判断必须使用equals 可以帮我们判断内容分是否相同
public class Cat {String name;String color;public Cat(String name, String color) {this.name = name;this.color = color;public static void main(String[] args) {//创建两个对象，他们的内存地址是不一样的Cat c1 = new Cat("球球", "黑白相间");Cat c2 = new Cat("球球", "黑白相间");System.out.println(c1 == c2);//false 双等默认判断的是两个对象的内存地址是否一致，一般用在基本数据类型上，判断两个数是否相等System.out.println(c1.equals(c2));//false object提供的equals方和==实际上是没有区别的}}
public class Cat {String name;String color;public Cat(String name, String color) {this.name = name;this.color = color;}//如果父类的满足不了就可以在子类中自己写equals方法public boolean equals(Cat c) {//单纯的去写判断的逻辑if (this.color == c.color) {return true;} else {return false;}}public static void main(String[] args) {//创建两个对象，他们的内存地址是不一样的Cat c1 = new Cat("球球", "黑白相间");Cat c2 = new Cat("球球", "黑白相间");System.out.println(c1 == c2);//false 双等默认判断的是两个对象的内存地址是否一致，一般用在基本数据类型上，判断两个数是否相等System.out.println(c1.equals(c2));//false object提供的equals方和==实际上是没有区别的//写了之后就会返回ture}}
注意： 字符串是例外的！！！这里不会报错
public class Cat {public static void main(String[] args) {//注：字符串是例外的//str1 、str2使用的是同一个内存地址String str1 = "小鲁";String str2 = "小鲁";//并没有单独的占内存空间System.out.println(str1 == str2);//tureSystem.out.println(str1.equals(str2));//ture}}
注意区别：这个时候新建了一个对象，虽然最初的内存地址是一样的但是new出来的str3和str4是不一样的是一个新的对象然后所以此时的内存地址是不一样的
public class Cat {public static void main(String[] args) {String str3 = new String("鲁正婷");String str4 = new String("鲁正婷");System.out.println(str3 == str4);//false 判断的是内存地址是否一致System.out.println(str3.equals(str4));//true 判断两个字符串的内容是否一直//字符串的判断必须使用equals 可以帮我们判断内容分是否相同}}
一个关于字符串的小练习：
！！！注意equals和==的区别！！！
//小练习模拟用户登录import java.util.Scanner;public class Test {public static void main(String[] args) {String Username = "admin";String Password = "123456";Scanner scan = new Scanner(System.in);System.out.print("请输入用户名");String uname = scan.nextLine();System.out.print("请输入密码");String upassword = scan.nextLine();//判断用户名和密码是否正确 用equals才行//if (uname==Username && upassword==Password) {//如果这个样子输入正确的也依旧会报错if (uname.equals(Username) && upassword.equals(Password)) {System.out.println("登录成功");}else {System.out.println("用户名或者密码错误！");}}}
toString()方法
tostring()对一个对象的字符串的表示形式Java推荐重写，默认的太繁杂
package MianXiangDuiXiang.ToString;public class Cat {String name;String color;public Cat(String name, String color) {this.name = name;this.color = color;}public static void main(String[] args) {Cat c = new Cat("球球", "白色");//直接打印cSystem.out.println(c);//默认打印对象，自动执行这个对象中的tostring()方法System.out.println(c.toString());//tostring()-->默认的是包.类@内存地址}}
重写toString()方法后
package MianXiangDuiXiang.ToString;public class Cat {String name;String color;public Cat(String name, String color) {this.name = name;this.color = color;}//子类对父类提供的方法不满意可以重写@Overridepublic String toString() {//return里面的内容可以自己写//用软件自带的更直观return "Cat{" +"name='" + name + '\'' +", color='" + color + '\'' +'}';}public static void main(String[] args) {Cat c = new Cat("球球", "白色");//直接打印cSystem.out.println(c);//默认打印对象，自动执行这个对象中的tostring()方法System.out.println(c.toString());//tostring()-->默认的是包.类@内存地址}}
instanceof关键字
interface:判断xxx对象是否属于xxx类型的
创建一个Animal类里面什么都不写
创建一个Cat类继承Animal类
public class Cat extends Animal {public static void main(String[] args) {Animal ani1 = new Cat();//向上转型Animal ani2 = new Animal();if (ani1 instanceof Cat) {//判断是否是一只猫System.out.println("是一只猫，你可以撸猫");} else {System.out.println("不是一只猫");}if (ani2 instanceof Cat) {//判断是否是一只猫System.out.println("是一只猫，你可以撸猫");} else {System.out.println("不是一只猫");}}}
内存分析
一共分成了4块区域
1.堆：主要存放对象
2.栈：局部变量以及基本数据类型的变量
3.代码区：类和方法
4.数据区：常量池和静态变量
参数传递问题
1.值传递：把变量的值作为参数进行传递
2.引用传递：直接把变量作为参数进行传递
Java使用的是值传递
内部类
内部类：就是在一个类中定义一个类（在一个类A中定义一个类B，类B就是内部类）内部类分访问特点：1.内部类可以直接访问外部类的成员，包括私有2.外部类访问内部类，不许创建对象
//格式：public class 类名{修饰符 class 类名{}}
成员内部类
创建Outer的外部类在里面定义内部类Inner
public class Outer {private int num = 10;public class Inner {//内部类访问外部类public void show() {System.out.println(num);}}}
测试内部类Inner
public class InnerDemo {public static void main(String[] args) {//创建内部类对象，并调用方法/*内部类创建对象的语法：外部类名.内部类名 对象名 = new 外部类名().new 内部类名();*/Outer.Inner inner = new Outer().new Inner();inner.show();}}
此时就可以访问到内部类Inner
但是当内部类改成私有的之后上面这个样子就无法进行访问
public class Outer {private int num = 10;//改成私有的之后测试方法就无法访问了private class Inner {public void show() {System.out.println(num);}}//外部访问内部public void method() {Inner inner = new Inner();inner.show();}}
此时就可以通过访问method方法进行访问内部类
public class InnerDemo {public static void main(String[] args) {//此时通过调用method方法来调用私有的方法[间接调用]Outer outer = new Outer();outer.method();}}
局部内部类
局部内部类：局部内部类是在方法中定义的类，所以外界无法直接使用，需要在方法内部创建对象并使用该类可以直接访问外部类的成员，也可以方法二点局部变量
public class Outer {private int num = 10;public void method() {// 局部内部类外界是无法直接进行访问的// 通过访问method方法进行间接访问class Inner {public void show() {System.out.println(num);System.out.println(num2);}}}}
此时进行测试
public class OuterDemo {public static void main(String[] args) {Outer outer = new Outer();outer.method();//此时访问为空}}
可以run一下发现结果是空的
这是通过创建对象调用方法来将show方法调用出来
public class Outer {private int num = 10;public void method() {// 局部内部类外界是无法直接进行访问的// 通过访问method方法进行间接访问class Inner {public void show() {System.out.println(num);System.out.println(num2);}}//此时创建Inner对象进行show方法的调用Inner inner = new Inner();inner.show();}}
再次运行就可以看到num的值
在method方法中定义局部变量
public void method() {//定义局部变量[此时再次运行的时候发现可以访问局部变量]int num2 = 20;
运行发现是可以访问局部变量的
匿名内部类
匿名内部类前提：存在一个类或者接口，这里的类可以是具体类也可以是抽象类
语法：//【new说明这是个对象只不过这个这个对象没有名字所以叫匿名对象】new 类名或者接口名（）{重写方法;//【重写方法说明它继承了前面的这个类或者说实现了一个接口】};
本质：是一个继承了该类或实现了该接口的子类匿名对象
public class Outer {public void method() {}}
public class OuterDemo {public static void main(String[] args) {}}
此时什么都没有
根据匿名内部类的语法创建一个接口
public interface Inter {void show();}
此时根据语法创建匿名对象
public class Outer {public void method() {//这里这样写仅仅是个对象new Inter() {@Overridepublic void show() {System.out.println("匿名内部类");}};//show();//不能这个样子调用}}
public class OuterDemo {public static void main(String[] args) {Outer outer = new Outer();outer.method();}}
可以发现上面注释掉的内容中调用show方法是不行的
将method方法中的匿名对象改成下面这个样子就可以进行调用了
new Inter() {@Overridepublic void show() {System.out.println("匿名内部类");}}.show();
如果调用多次将上面的内容多粘贴几次就可以了，但是你会发现这样写就显得过分冗余了
这是一个对象就会有返回值类型这里我们new的是一个接口Inter而且在里面重写了show方法所以这个整体可以看成Inner的实现类对象既然可以将看成是实现类对象那么久可以用多态的形式赋值给接口
可以发现效果是一样的
Inter inter = new Inter() {@Overridepublic void show() {System.out.println("匿名内部类");}};//和刚刚是一个效果inter.show();inter.show();
匿名内部类在将开发中的使用
创建接口Jumpping
public interface Jumpping {void jump();}
创建接口操作类JumppingOperator
public class JumppingOperator {public void method(Jumpping jumpping) {//需要的是该接口的实现类对象//所以创建一个类Catjumpping.jump();}}
创建测试类JumppingDemo
public class JumppingDemo {public static void main(String[] args) {//需求：创建接口操作类的对象，调用method方法JumppingOperator j = new JumppingOperator();}}
由于需要的是该接口的实现类对象，所以创建一个类Cat
public class Cat implements Jumpping {//注意一定要在Jumpping中进行实现@Overridepublic void jump() {System.out.println("我是一只小猫，我可以跳很高");}}
这个时候再在测试类中进行实例化
public class JumppingDemo {public static void main(String[] args) {//需求：创建接口操作类的对象，调用method方法JumppingOperator j = new JumppingOperator();Jumpping jumpping = new Cat();j.method(jumpping);}}
这里的接口操作类JumppingOperator相当于是一个中转类，作用是实现jump方法
再创建一个Dog类就可以体会的更清晰点
public class Dog implements Jumpping {@Overridepublic void jump() {System.out.println("我是一只小狗，我也会跳");}}
测试类中调用
public class JumppingDemo {public static void main(String[] args) {//需求：创建接口操作类的对象，调用method方法JumppingOperator j = new JumppingOperator();Jumpping jumpping = new Cat();Jumpping jumpping1=new Dog();j.method(jumpping);j.method(jumpping1);}}
异常处理
异常就是错误对象编译时异常：语法不通过程序会报红运行时异常：编译可以通过，但是运行会出错1.异常是错误，进行时异常（不是编译异常）2.抛异常，创建一个错误对象，把错误对象丢出来3.捕获异常，默认有JVM来把错误信息进行捕获，打印出来。JVM会终止程序的执行【一旦发现错误之后、所以不能用JVM来捕获异常】
异常的分类
1.RuntimeException:运行时异常，一般不手动处理，出了问题再处理2.其他Exception:必须要经过手动处理3.Error:一般指的是系统级错误
异常处理的语法句子
//try...catch语法：try{尝试执行的代码}catch(Exception){处理异常的代码}//try...catch...finnally语法：try{尝试执行的代码}catch(Exception){处理异常的代码}finally{最终的}
异常处理的示例：
public class Test {public static void main(String[] args) {try {System.out.println(1 / 0);} catch (Exception e) {// e.printStackTrace(); // 打印错误信息 //给程序员看的System.out.println("系统出错了！请联系程序员！！"); //给客户看的} finally {System.out.println("这里时finally部分");}}}
使用printStackTrace()可以将错误信息打印出来
↓ 是给程序员看的
java.lang.ArithmeticException: / by zeroat MianXiangDuiXiang.YiChangChuLi.Test.main(Test.java:39)
如果是给客户看就 👇
System.out.println("系统出错了！请联系程序员！！");
注：finally部分无论是否出错都会运行
抛异常处理throws和throw【少用为妙】
throws：表示方法准备扔出来一个异常产生的错误尽可能自己处理，少向外抛出异常throw：表示向外抛出异常
public class Test2 {public static void read() throws Exception {//[throws Exception <--可能抛出异常↓]/表示当前这个方法会扔出来Exception这样的错误InputStream is = new FileInputStream(new File("为什么呢？？"));}public static void main(String[] args) throws Exception {read();}}
会出现错误：
使用throw抛出异常
public class Test2 {public static void chu(int a, int b) throws Exception {//告诉外面我要仍出来一个错误if (b == 0) {//如果b=0，抛出如下错误throw new Exception("当前位置不可以为0");//真正抛出来一个异常} else {System.out.println(a / b);}}public static void main(String[] args) throws Exception {chu(5, 0);}}
如文章有错误还请大佬指教🤞
