封装
高内聚，低耦合，程序设计追求
封装，将数据隐藏，设置接口进行交互，就是属性私有private
package oop.demo;
public class Student {
private int id;
private int age;
private String name;
public Student() {
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public int getAge() {
return age;
}
public void setAge(int age) {
if (age<0 || age>120){
this.age = 0;
}else
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Student(int id, int age, String name) {
this.id = id;
this.age = age;
this.name = name;
}
}
//封装就是将类的属性私有，使其他程序再调用此类时不能直接调用，而是走我们设计的方法接口进行调用，并且可以在我们自己设计的方法接口中进行一些简单的判断用于用户交互，提高了安全性，可维护性
继承
实际就是对类进行抽象，提取类中的共同点
子类继承了父类就会拥有父类的全部方法，也拥有父类非私有的属性
快捷键ctrl + h
public class Students extends Person{
}
public class Person {
int age;//属性添加了private修饰之后子类就不能直接使用此属性了
public void say(){
System.out.println("sssssss");
}
}
public class Demo1 {
public static void main(String[] args) {
Students students = new Students();
students.age = 10;
say(students);
}
public static void say(Students students){
System.out.println(students.age);
}
}
再java中，所有的类都默认继承object类
只有单继承，没有多继承，一个父类可以有多个子类，但是一个子类只能有一个父类
package oop.demo;
public class Students extends Person{
String name;
public Students() {
super();//有隐藏代码，super();默认调用父类的构造器无参构造，且显示写出时super（）方法必须放在第一行
//this("sang");this()方法，再调用本类中的构造方法时必须放在第一行
//并且去掉上一行super（）方法还是能够调用父类构造方法
System.out.println("Student被调用了！");
}
public Students(String name) {
this.name = name;
}
}
//若父类只有有参构造方法，则子类中不能够写无参构造若要写则必须显示调用super（）方法进行显示有参调用
super注意点
1、super调用父类的构造方法，必须在在构造方法中的第一句
2、super必须只能出现在子类的方法或者构造方案中
3、super和this不能同时调用构造方法
super与this：代表的对象不同、前提不同、构造方法不同
this：代表本身调用者这个对象
super：代表父类的应用
this：没有继承关系也可使用，super：只能在继承关系中使用
this（）： 本类的构造方法，super（）父类的构造方法
方法重写
package oop.demo;
public class Teacher{
public static void main(String[] args) {
A a = new A();
a.test();
//父类的引用指向子类
B b = new A();
b.test();
}
}
这个我第一次测试的时候父类和子类都没有用static修饰，跑出来的结果都是A，用了static修饰过后跑出来的结果就是一A一B了
package oop.demo;
//重写都是方法的重写和属性无关
public class B {
public static void test(){
System.out.println("B");
}
}
package oop.demo;
public class A extends B{
public static void test(){
System.out.println("A");
}
}
package oop.demo;
public class Teacher{
public static void main(String[] args) {
//静态方法：方法的调用只与左边定义的数据类型有关
//重写的关键词只能是public，private就不是重写了
//非静态：重写
A a = new A();
//没加static都是A，加上变成A，B
a.test();//A A
//父类的引用指向子类
B b = new A();
b.test();//A B
}
}
/*重写：需要有继承关系，子类重写父类的方法！
1、方法名必须相同
2、参数列表必须相同
3、修饰符：子类修饰符范围可以扩大但不能缩小public>protested> Default>private
4、抛出的异常：范围，可以被缩小，但不能扩大
重写，子类的方法和父类的必要一致，方法体不同！
为什么需要重写：
父类的功能子类不一定需要，或不一定会满足！Alt+ Insert：override
*/
多态
动态编译，可扩展性增强
package oop.test;
public class Application {
public static void main(String[] args) {
//new Student（）；一个对象的实际类型是可以被确认的
//可指向的引用类型就不确定了，父类的引用指向子类
Student student = new Student();
//编译看左边，运行看右边
Person student1 = new Student();
//Student能调用的方法都是自己或者继承父类的
//Person父类型，可以指向子类，但是不能调用子类独有的方法
Object student2 = new Student();
//对象能执行哪里的方法主要看左边，和右侧关系不大！
student1.run();//子类重写了父类的方法执行子类
student.run();
student.study();
((Student)student1).study();//父类引用要调用子类方法只能强制转换
//多态是方法的多态，属性没有多态
//父类和子类，有联系 ，类型转换异常
//存在条件，继承关系，方法需要重写，父类引用指向子类对象！
//static 方法，属于类，不属于实例，不能重写
//final 常量
//private 方法私有，
}
}
package oop.test;
public class Person {
public void run(){
System.out.println("Person!");
}
}
package oop.test;
public class Student extends Person
{
@Override
public void run() {
System.out.println("Student!");
}
public void study(){
System.out.println("study");
}
}
instanceof//类型转换，引用类型 ， 判断一个类是什么类型，判断是否继承关系
package oop.test;
public class Application {
public static void main(String[] args) {
Student student = new Student();
Person person = new Student();
Object object = new Student();
Teacher teacher = new Teacher();
Person person1 = new Teacher();
System.out.println("---------------");
System.out.println(student instanceof Student);//true
System.out.println(student instanceof Person);//true
System.out.println(student instanceof Object);//true
//System.out.println(student instanceof Teacher);//报错，编译不通过
//System.out.println(student instanceof String);//报错，编译不通过
System.out.println(person instanceof Student);//true
System.out.println(person instanceof Person);//true
System.out.println(person instanceof Object);//true
System.out.println(person instanceof Teacher);//false
// System.out.println(person instanceof String);//报错，编译不通过
System.out.println(object instanceof Student);//true
System.out.println(object instanceof Person);//true
System.out.println(object instanceof Object);//true
System.out.println(object instanceof Teacher);//false
System.out.println(object instanceof String);//false
//instanceof 判断A与B是否是继承关系，A实例对象，B引用类型
student.run();//强制类型转换，子转父，默认转换。，子转父可能会导致一些方法不能使用
((Student)person).study();//父转子,可以使用子类方法，需要添加括号强制转换
}
}
// //new Student（）；一个对象的实际类型是可以被确认的
// //可指向的引用类型就不确定了，父类的引用指向子类
// Student student = new Student();
// //编译看左边，运行看右边
// Person student1 = new Student();
// //Student能调用的方法都是自己或者继承父类的
// //Person父类型，可以指向子类，但是不能调用子类独有的方法
// Object student2 = new Student();
// //对象能执行哪里的方法主要看左边，和右侧关系不大！
// student1.run();//子类重写了父类的方法执行子类
// student.run();
// student.study();
//
// ((Student)student1).study();//父类引用要调用子类方法只能强制转换
// //多态是方法的多态，属性没有多态
// //父类和子类，有联系 ，类型转换异常
// //存在条件，继承关系，方法需要重写，父类引用指向子类对象！
// //static 方法，属于类，不属于实例，不能重写
// //final 常量
// //private 方法私有，
static
package oop.test;
public class Demo2 {
private static char c;
protected static byte b;
public static int i;
public String name;
{//第二个执行，实例化对象时，最先执行
System.out.println("匿名代码块！");
}
static {//最先执行，且只执行一次，随着类的加载而加载
System.out.println("静态代码块！");
}
public Demo2() {//与上相比最后执行
System.out.println("构造方法！");
}
}
package oop.test;
public class Demo3 {
public static void main(String[] args) {
Demo2 demo2 = new Demo2();
System.out.println(demo2.name);//成员变量需实例化对象才能访问
System.out.println(Demo2.b);//静态变量 protected修饰，可以直接类名调用
System.out.println(Demo2.i);//静态变量 public修饰，可以直接类名调用
//System.out.println(Demo2.c);//c 在 Demo2 中是 private 访问控制,直接报错
}
}
package oop.test;
//静态导入方法，可直接使用类中的方法
import static java.lang.Math.random;
import static java.lang.Math.PI;
//若类被 final 修饰，则无法被继承
public final class Demo4 {
public static void main(String[] args) {
System.out.println(Math.random());//Math类中的方法，生成0-1内的随机数
System.out.println(random());
System.out.println(PI);//静态导入类中的常量，可直接使用，不需要添加类名
}
}
抽象类
package oop.exercise;
//使用abstract修饰的类，被称为抽象类
public abstract class Demo1 {
//被abstract修饰的方法为抽象方法，抽象方法没有方法体
public abstract void say();
public void test(){
System.out.println();
}
}
package oop.exercise;
//若此类继承了抽象类，则必须实现其中全部的抽象方法，除非此类也为抽象类
//java中，类都是单继承1关系，接口除外（接口可以实现多继承）
//抽象类不能new出实例，只能靠子类去实现他，它就是一个约束！
//抽象类中可以实现具体方法，抽象方法只能在抽象类中
public class Demo2 extends Demo1{
@Override
public void say() {
}
}
接口
package oop.exercise;
//interface定义的关键字，接口
public interface Demo3 {
//接口中的所有定义都是抽象的，默认是public abstract,接口中的属性必须赋值。默认是public static final 常量
int a = 0;
int add(int a,int b);
int delete(int d);
int query(int d);
int update(int d);
}
package oop.exercise;
//类可以通过implements关键字来实现接口，必须实现其全部方法,
// implements可以实现多个接口
//接口中只有方法的定义，接口可以多继承
//接口不能被实例化，接口没有构造方法
//是一个约束，可以让不同的人实现
public class Demo4 implements Demo3{
@Override
public int add(int a, int b) { return 0; }
@Override
public int delete(int d) { return 0; }
@Override
public int query(int d) { return 0; }
@Override
public int update(int d) { return 0; }
}
内部类
package oop.exercise;
public class Demo6 {
public static void main(String[] args) {
Demo5 demo5 = new Demo5();
//内部类实例化需要通过外部类实例再对内部类进行实例
Demo5.In in = demo5.new In();
in.in();
in.getId();
//没有名字的初始化类，不用将实例保存再变量中
new B().toString();
new C() {//匿名内部类，实现接口，但要重写里面的方法
@Override
public void add() {
}
};
}
public void testDemo(){
class A{
//局部内部类
}
}
}
//一个java文件可以有多个class，但只能有一个public class
class B{
}
interface C{
void add();
}
package oop.exercise;
public class Demo5 {
private int id;
public void out(){
System.out.println("这是外部类方法!");
}
public Demo5(){
this.id = 10;
}
//内部类可以看作是外部类的成员类
public class In{
public void in(){
System.out.println("这是内部类方法!");
}
//可以获得外部类的私有属性
public void getId(){
System.out.println(id);
}
}
}