Java基础-类
封装
禁止直接访问一个对象中数据的实际使用，而通过操作接口来访问，这称为信息的隐蔽。
总结来说就是使用私有变量，通过get/set方法来对参数进行操作
public class Person {
private String name = "test";
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public static void main(String[] args){
Person p1 = new Person();
System.out.println(p1.getName());
p1.setName("Th0r");
System.out.println(p1.getName());
}
}
//test
//Th0r
继承
extends
继承是类与类之间的一种关系，除了继承之外还有依赖、组合、聚合等。
继承关系两个类，一个父类、一个子类。子类继承父类，使用关键字extends来表示。子类拥有父类非 private 的属性、方法。
需要注意的是 Java 不支持多继承，但支持多重继承。
//Person类
public class Person {
private String name = "test";
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
//Student类
public class Student extends Person {
private String school;
public String getSchool() {
return school;
}
public void setSchool(String school) {
this.school = school;
}
public static void main(String[] args){
Student s1 = new Student();
System.out.println(s1.getName());
s1.setSchool("No.1");
System.out.println(s1.getSchool());
}
}
Ctrl + H 打开继承树 java中所有类默认继承Object类
super
super关键字：我们可以通过super关键字来实现对父类成员的访问，用来引用当前对象的父类。
Person类
package basic.demo3;
public class Person {
public Person() {
System.out.println("It's class Person");
}
public Person(String name) {
System.out.println(name);
}
protected String name = "Person";
public void print(){
System.out.println("Print Person");
}
}
Student类
package basic.demo3;
public class Student extends Person{
public Student() {
super("Super");
System.out.println("It's class Student");
}
private String name = "Student";
public void print(){
System.out.println("Print Student");
}
public void test(String name){
System.out.println("参数：");
System.out.println(name);
System.out.println(this.name);
System.out.println(super.name);
System.out.println("方法：");
print();
this.print();
super.print();
}
}
App类
package basic.demo3;
public class App {
public static void main(String[] args){
System.out.println("构造器：");
Student s1 = new Student();
s1.test("Test");
}
}
输出
/**
构造器：
Super
It's class Student
参数：
Test
Student
Person
方法：
Print Student
Print Student
Print Person
**/
- 当没有super关键词时 默认按顺序执行无参构造器
- 当有super关键词但参数为空时，只执行父类无参构造器
- 当有super关键词且参数不为空时，只执行父类有参构造器
注意点
- super调用父类的构造方法，必须在构造方法的第一个，
- super只能出现在子类的方法或构造方法中
- super和this不能同时构造方法
重写
重写是子类对父类的允许访问的方法的实现过程进行重新编写, 重写的好处在于子类可以根据需要，定义特定于自己的行为。 也就是说子类能够根据需要实现父类的方法。
Override
- 方法名必须相同
- 参数列表必须相同
- 修饰符范围可以扩大但不可以缩小： public>protected>default>private
- 抛出的异常的范围只能缩小
public class B {
public void test(){
System.out.println("Test=>B");
}
}
public class A extends B {
@Override
public void test(){
System.out.println("Test=>A");
}
}
public class App {
public static void main(String[] args) {
A a = new A();
a.test();
//父类的引用指向子类 向上转型
B b = new A();
b.test();
}
}
//Test=>A
//Test=>A
static
public class B {
public static void test(){
System.out.println("Test=>B");
}
}
public class A extends B {
public static void test(){
System.out.println("Test=>A");
}
}
public class App {
public static void main(String[] args) {
//方法的调用只和左边定义的类型有关
A a = new A();
a.test();
B b = new A();
b.test();
}
}
//Test=>A
//Test=>B
- 静态方法是类的方法，而非静态方法是对象的方法
- 有static时，b调用了B类的方法，因为b是用B类定义的
- 无static时，b调用是的对象的方法，而b是A类new的
多态
即同一方法可以根据发送对象的不同而采用多种不同的行为方式。一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多。
多态存在的条件
- 有继承关系
- 子类重写父类方法
- 父类引用指向子类对象
package basic.demo5;
public class Person {
public void eat(){
System.out.println("Person eat");
}
}
//Student
public class Student extends Person {
@Override
public void eat() {
System.out.println("Student eat");
}
public void study() {
System.out.println("Student study");
}
}
//App
public class App {
public static void main(String[] args) {
Student s1 = new Student();
Person s2 = new Student();
Object s3 = new Student();
s1.eat();
s1.study();
s2.eat();
//s2.study();
((Student) s2).study();
//s3.eat();
//s3.study();
//注释表示语句错误的
}
}
/**
Student eat
Student study
Student eat
Student study
**/
- 子类重写了父类的方法，不管左边的类型，均执行子类的方法
- 对象能执行哪些方法，主要看左边的类型
- 父类可以指向子类，但不能调用子独有的方法
instanceof
instanceof 是 Java 的一个二元操作符，类似于 ==，>，< 等操作符。
instanceof 是 Java 的保留关键字。它的作用是测试它左边的对象是否是它右边的类的实例，返回 boolean 的数据类型。
Object o = new Student();
System.out.println(o instanceof Student); //true
System.out.println(o instanceof Person); //true
System.out.println(o instanceof Object); //true
Student s = new Student();
System.out.println(s instanceof Student); //true
System.out.println(s instanceof Person); //true
System.out.println(s instanceof Object); //true
Person person = new Person();
System.out.println(person instanceof Student); //false
System.out.println(person instanceof Person); //true
System.out.println(person instanceof Object); //true
Object object = new Object();
System.out.println(object instanceof Student); //false
System.out.println(object instanceof Person); //false
System.out.println(object instanceof Object); //true
这里我理解为是前面的否能向后面的向上转型
static
在Java中并不存在全局变量的概念，但是我们可以通过static来实现一个“伪全局”的概念，在Java中static表示“全局”或者“静态”的意思，用来修饰成员变量和成员方法，当然也可以修饰代码块。
package basic.demo6;
public class Student {
private static int sex=1;
private double score=100;
public static void go(){
}
public void run(){
}
public static void main(String[] args) {
System.out.println(Student.sex);
go();
Student s = new Student();
System.out.println(s.score);
s.run();
}
}
静态变量和静态方法可以不用实例化对象直接执行
静态代码块
package basic.demo6;
public class Person {
{
System.out.println("匿名方法");
}
static {
System.out.println("静态代码块");
}
public Person(){
System.out.println("构造方法");
}
public static void main(String[] args) {
Person p1 = new Person();
System.out.println("-----------------------");
Person p2 = new Person();
}
}
/**
静态代码块
匿名方法
构造方法
-----------------------
匿名方法
构造方法
**/
静态代码块>匿名方法>构造方法 静态代码块只执行一次 即使不实例化也能执行
抽象类
- 抽象类不能被实例化(初学者很容易犯的错)，如果被实例化，就会报错，编译无法通过。只有抽象类的非抽象子类可以创建对象。
- 抽象类中不一定包含抽象方法，但是有抽象方法的类必定是抽象类。
- 抽象类中的抽象方法只是声明，不包含方法体，就是不给出方法的具体实现也就是方法的具体功能。
- 构造方法，类方法（用 static 修饰的方法）不能声明为抽象方法。
- 抽象类的子类必须给出抽象类中的抽象方法的具体实现，除非该子类也是抽象类。
public abstract class Student
{
private String name;
public abstract double grade();
//其余代码
}
接口
接口，在JAVA编程语言中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法。
接口并不是类，编写接口的方式和类很相似，但是它们属于不同的概念。类描述对象的属性和方法。接口则包含类要实现的方法。
除非实现接口的类是抽象类，否则该类要定义接口中的所有方法。
接口无法被实例化，但是可以被实现。一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须声明为抽象类。另外，在 Java 中，接口类型可用来声明一个变量，他们可以成为一个空指针，或是被绑定在一个以此接口实现的对象。
package basic.demo7;
public interface Calc {
//接口中所有定义的方法都是抽象的
int add(int a, int b);
int sub(int a, int b);
}
public interface Test {
void print();
}
public class CalcImpl implements Calc, Test {
@Override
public int add(int a, int b) {
return 0;
}
@Override
public int sub(int a, int b) {
return 0;
}
@Override
public void print() {
}
}
异常处理
异常是程序中的一些错误，但并不是所有的错误都是异常，并且错误有时候是可以避免的。
package basic.demo8;
public class Test {
public void test(int i) throws ArithmeticException {
//当前方法不能处理异常时，抛出给上一层
if (i==0) {
throw new ArithmeticException();
}
}
public static void main(String[] args) {
int a=1;
int b=0;
try{ //监控区域
System.out.println(a/b);
}catch (Error e){ //捕获的异常类型 顺序从小到大
System.out.println("Error");
}catch (Exception e){
System.out.println("Exception");
}finally {
System.out.println("finally");
}
}
}
快捷键 Ctrl + Alt + t 自动包裹语句
