public class father {
private int age;
public static void main(String[] args) {
father dad = new father();
}
father()
{
System.out.println("father的构造方法");
}
father(int age)
{
System.out.println("father的有参构造");
this.age = age;
System.out.println(age);
}
}
public class father {
private int age;
public static void main(String[] args) {
father dad = new father(40);
}
father()
{
System.out.println("father的构造方法");
}
father(int age)
{
System.out.println("father的有参构造");
this.age = age;
System.out.println(age);
}
}
1702971062277.png
this 关键字
主要的作用就是避免重名歧义，比如类中有一个 age 变量，使用 setAge (int age) 赋值时，函数中的形参与类内的 age 变量就重名了，那么就可以用 this 关键字进行区分
public class father {
private int age;
public void setAge(int age)
{
//this关键字指的就是father这个类的age成员变量
this.age = age;
}
}
toString()
class 是引用数据类型，如果定义一个类，然后再用这个类创建一个对象，如果我们想要打印该对象中的实例变量就需要 tostring 方法，内置的 tostring 方法会打印出 类名@奇怪的数字。所以要重写 tostring 方法
public class temp {
int x;
int y;
public static void main(String[] args) {
temp t = new temp();
System.out.println(t);
}
@Override
public String toString() {
//返回想要打印的字符串
return "x" + '=' + x +'\n'+'y'+'='+y;
}
}
1702990665430.png
封装
封装是指隐藏对象的内部实现细节，用户必须通过指定的方法才能操作 对象的属性。在上面的代码中，如果在 father 类外对 age 变量进行赋值，就必须使用 setAge(int age) 函数。
访问权限
1702971253974.png
继承
继承可以让子类继承父类中的成员变量以及方法。一个父类可以有多个子类，但是一个子类只能拥有一个父类。如果 father 有一个子类 son，son 需要继承父类
静态方法，属于类，而不属于类的对象。 1）它通过类直接被调用，无需创建类的对象。 2）静态方法中，不能使用 this 关键字，也不能直接访问所属类的实例变量和实例方法； 3）静态方法中，可以直接访问所属类的静态变量和静态方法。 4）同 this 关键字，super 关键字也与类的实例相关，静态方法中不能使用 super 关键字。
public abstract class Test {
public abstract void test01();//抽象方法
//非抽象方法
public void test02() {
System.out.println("test");
}
}
接口类
接口的声明
public interface Study{ //使用interface表示这是一个接口
void study();
}
接口的继承
public class Student extends Person implements Study { //使用implements关键字来实现接口
public Student(String name, int age, String sex) {
super(name, age, sex, "学生");
}
@Override
public void study() { //实现接口时，同样需要将接口中所有的抽象方法全部实现
System.out.println("我会学习！");
}
}
接口中只定义访问权限为 public 抽象方法，其中 public 和 abstract 关键字可以省略
private final int value; //类中实际上就靠这个变量在存储包装的值
public Integer(int value) {
this.value = value;
}
包装类支持自动装箱，以及自动拆箱，有了这两个特性，就可以让包装类型参与到基本类型的运算中
//自动装箱
public static void main(String[] args) {
Integer i = 10; //将int类型值作为包装类型使用
}
//自动装箱的实质
public static void main(String[] args) {
Integer i = Integer.valueOf(10); //上面的写法跟这里是等价的
}
//自动拆箱
public static void main(String[] args) {
Integer i = 10;
int a = i;
}
//自动拆箱的实质
public static void main(String[] args) {
Integer i = 10;
int a = i.intValue(); //通过此方法变成基本类型int值
}
//包装类参与基本运算
public static void main(String[] args) {
Integer a = 10, b = 20;
int c = a * b; //直接自动拆箱成基本类型参与到计算中
System.out.println(c);
}
public class Test {
public class Inner { //内部类也是类，所以说里面也可以有成员变量、方法等，甚至还可以继续套娃一个成员内部类
public void test(){
System.out.println("我是成员内部类！");
}
}
}
成员内部类和成员方法、成员变量一样，都是属于对象的，使用的时候需要先创建对象
public static void main(String[] args) {
Test test = new Test(); //我们首先需要创建对象
Test.Inner inner = test.new Inner(); //成员内部类的类型名称就是 外层.内部类名称
}
//使用成员内部类中的方法：
public static void main(String[] args) {
Test test = new Test();
Test.Inner inner = test.new Inner();
inner.test();
}
public class Test {
private final String name;
public Test(String name){
this.name = name;
}
public class Inner {
public void test(){
System.out.println("我是成员内部类："+name);
//成员内部类可以访问到外部的成员变量
//因为成员内部类本身就是某个对象所有的，每个对象都有这样的一个类定义，这里的name是其所依附对象的
}
}
}
public static void main(String[] args) {
Test a = new Test("小明");
Test.Inner inner1 = a.new Inner(); //依附于a创建的对象，那么就是a的
inner1.test();
Test b = new Test("小红");
Test.Inner inner2 = b.new Inner(); //依附于b创建的对象，那么就是b的
inner2.test();
}
那现在问大家一个问题，外部能访问内部类里面的成员变量吗？
那么如果内部类中也定义了同名的变量，此时我们怎么去明确要使用的是哪一个呢？
public class Test {
private final String name;
public Test(String name){
this.name = name;
}
public class Inner {
String name;
public void test(String name){
System.out.println("方法参数的name = "+name); //依然是就近原则，最近的是参数，那就是参数了
System.out.println("成员内部类的name = "+this.name); //在内部类中使用this关键字，只能表示内部类对象
System.out.println("成员内部类的name = "+Test.this.name);
//如果需要指定为外部的对象，那么需要在前面添加外部类型名称
}
}
}
包括对方法的调用和super关键字的使用，也是一样的：
public class Inner {
String name;
public void test(String name){
this.toString(); //内部类自己的toString方法
super.toString(); //内部类父类的toString方法
Test.this.toString(); //外部类的toSrting方法
Test.super.toString(); //外部类父类的toString方法
}
}
//创建一个静态内部类Inner
public class Test {
private final String name;
public Test(String name){
this.name = name;
}
public static class Inner {
public void test(){
System.out.println("我是静态内部类！");
}
}
}
//实例化一个内部类
public static void main(String[] args) {
Test.Inner inner = new Test.Inner(); //静态内部类的类名同样是之前的格式，但是可以直接new了
inner.test();
}
静态内部类是无法直接访问外部非静态内容
匿名内部类
一种局部内部类的简化版，一般用于抽象类以及接口的实例化过程
//抽象类
public abstract class Student {
public abstract void test();
}
//在方法中使用 匿名内部类，将其中的抽象方法实现，并直接创建实例对象
public static void main(String[] args) {
Student student = new Student() { //在new的时候，后面加上花括号，把未实现的方法实现了
@Override
public void test() {
System.out.println("我是匿名内部类的实现!");
}
};
student.test();
}
