Java中关于成员变量初始值、内部类、异常处理
目录
成员变量初始值
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=0
short s;//short=0
int i;//int=0
long l;//long=0
float f;//float=0.0
double d;//double=0.0
char c;//char= //注意这里是有一个空格的
//System.out.println("char="+(int)p.c);//强转成int型-->0
boolean bool;//boolean=false
String str;// String是Java提供的一个类//String=null
Child child;//自己写的类Child的默认值//Child=nullObject
万事万物皆为对象 所有的东西都是对象 在Java中所有的类都要继承object object是一个类，所有类的根 我们的写的类即使不写继承关系，那么默认也会继承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);}
}
如文章有错误还请大佬指教🤞
本文来自互联网用户投稿，文章观点仅代表作者本人，不代表本站立场，不承担相关法律责任。如若转载，请注明出处。 如若内容造成侵权/违法违规/事实不符，请点击【内容举报】进行投诉反馈！