学习Java第2天-Java类
学习Java第2天-Java类
本次更新实际上距离上次第一天已经过去2周,中间没有更新,主要是因为涉及到的循环控制语句,函数等都比较简单,学起来没啥压力,感觉没有记录的必要。昨天看完了类的课程,涉及的东西比较多,在此对重要的点记录一下。
java类权限控制
public
public是公共的,被public所修饰的成员可以在任何类中都能被访问到。
public能用来修饰类,在一个java源文件中只能有一个类被声明为public,而且一旦有一个类为public,那这个java源文件的文件名就必须要和这个被public所修饰的类的类名相同,否则编译不能通过。说到这里,穿插多一点知识。一个类作为外部类的时候只能被public或者默认访问修饰符所修饰,但是一个类如果作为内部类的时候,则可以被四种访问修饰符所修饰,因为一个类作为内部类的时候,就作为外部类的一个成员属性了,因此可以有四种访问修饰符修饰,这是内部类和外部类的一个区别
public用来修饰类中成员(变量和方法),被public所修饰的成员可以在任何类中都能被访问到。通过操作该类的对象能随意访问public成员。
public在类的继承上的体现,被public所修饰的成员能被所有的子类继承下来。
protected
protected是受保护的,受到该类所在的包所保护。
被protected所修饰的成员会被位于同一package中的所有类访问到。同时,被protected所修饰的成员也能被该类的所有子类继承下来。(注意:这里是指同一个package或者不同的package中的子类都能访问)
default(friendly)
friendly是友好的,即在成员的前面不写任何的访问修饰符的时候,默认就是友好的。所谓友好的,是对同一package的类友好。
同一package中的所有类都能访问。被friendly所修饰的成员只能被该类所在同一个package中的子类所继承下来。(也就是说只有在同一个package中的子类才能访问到父类中friendly修饰的成员)
private
private是私有的,即只能在当前类中被访问到,它的作用域最小。
作用域 | 当前类 | 同一包 | 其他包的子类 | 其他包的类 |
---|---|---|---|---|
public | √ | √ | √ | √ |
protected | √ | √ | √ | × |
default | √ | √ | × | × |
private | √ | × | × | × |
java类构造器
相当于python中的def __init__(self)函数,不过java和python不同,python构造函数传递默认值是形参设置,而java则利用同名函数机制,实现可不传递参数,实例化类,也可传递部分参数,实例化类。
idea中快速构造器快捷键:control + enter
必须与类名相同
无返回值
java类的高内聚、低耦合实现
get/set
idea快捷键:control + enter
原则:成员不应暴露给外部直接调用,而应该将属性保护起来,提供get/set方法来操作成员属性。
Demo
Person.java
package top.junyipan.www.Entity;
public class Person {
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
public Boolean getSex() {
return sex;
}
public void setSex(Boolean sex) {
this.sex = sex;
}
String name;
Integer age;
Boolean sex;
public Person() {
this.sex = false;
this.age = 10;
}
public Person(String name, Integer age, Boolean sex) {
this.name = name;
this.age = age;
this.sex = sex;
}
protected void eating() {
System.out.println(this.name + "正在吃饭");
}
protected static void sleep(){
System.out.println("人正在床上睡觉!");
}
}
Student.java
package top.junyipan.www.Entity;
public class Student extends Person{
protected void learn() {
System.out.println(this.name + "正在学习!");
}
protected void exam() {
System.out.println(this.name + "正在考试!");
}
protected int getRank() {
return 10;
}
@Override
protected void eating() {
System.out.println(this.name + "吃火锅!");
}
protected static void sleep() {
System.out.println("学生正在桌上睡觉!");
}
}
Teacher.java
package top.junyipan.www.Entity;
public class Teacher extends Person{
protected void speaking() {
System.out.println(this.name + "正在讲课!");
}
}
Main.java
package top.junyipan.www.Entity;
public class Main {
public static void main(String[] args) {
Teacher wang = new Teacher();
wang.setName("老王");
wang.setAge(35);
wang.setSex(true);
Student xm = new Student();
xm.setName("小明");
xm.setAge(12);
xm.setSex(true);
Student xh = new Student();
xh.setName("小红");
xh.setAge(14);
System.out.println(wang.getAge());
System.out.println(xh.getName());
System.out.println(xh.getAge());
System.out.println(xh.getSex());
wang.speaking();
xm.learn();
xh.learn();
wang.eating();
xm.eating();
xm.exam();
System.out.println("小明考试成绩排名第" + xm.getRank());
System.out.println("======================");
Student s1 = new Student();
s1.setName("s1");
Person s2 = new Student();
s2.setName("s2");
s1.eating();
s1.sleep();
s2.eating();
s2.sleep();
}
}
35
小红
14
false
老王正在讲课!
小明正在学习!
小红正在学习!
老王正在吃饭
小明吃火锅!
小明正在考试!
小明考试成绩排名第10
======================
s1吃火锅!
正在桌上睡觉!
s2吃火锅!
正在床上睡觉!
封装-继承-多态
- 继承:extends
- 多态
- 父类和子类有相同的方法和参数
- 多态是方法的多态,属性没有多态
- 存在条件:继承关系,方法需要重写,父类引用指向子类对象
- 如果是static方法,最终调用的方法看左边;如果不是static方法,调用的是右边实例对象的方法
- Student student = new Student(); student.eat() 调用的Student的eat方法
- Person student = new Student(); student.eat()调用的Person的eat方法
- 不可继承的场景:
- static方法,属于类,不属于实例
- final 常量
- private 方法(private方法不可继承,谈不上多态)
抽象类
-
关键字 abstract,一般写框架的时候会用,定义方法,但是不会实现它
-
抽象类不能被实例化,有构造方法
-
抽象类中的方法不一定全部是抽象方法,但是有抽象方法的类一定是抽象类
-
继承抽象类的子类也可以是抽象类,如果子类不是抽象类,则必须要实现父类的抽象方法
cooking.java
package top.junyipan.www.demo1; /*抽象类*/ public abstract class Cooking { /*抽象方法*/ public abstract void buyFood(); public abstract void washFood(); public abstract void cookFood(); /*非抽象方法*/ public void eatFood(){ System.out.println("nice food!"); } }
cooker.java
package top.junyipan.www.demo1; public class Cooker extends Cooking{ @Override public void buyFood() { System.out.println("buying food..."); } @Override public void washFood() { System.out.println("washing food..."); } @Override public void cookFood() { System.out.println("cooking food..."); } }
Main.java
package top.junyipan.www.demo1; public class Main { public static void main(String[] args) { Cooker wang = new Cooker(); wang.buyFood(); wang.washFood(); wang.cookFood(); wang.eatFood(); } }
接口
- 关键字interface,不再用class修饰
- 接口中的方法默认就是使用public abstract来修饰,表示公共抽象方法
- 接口中定义的方法,在实现接口的类中必须实现
- 接口中定义的属性是public static final修饰,但是一般接口中不定义属性
- 接口不能被实例化,接口中没有构造方法