package com.oop.demo06;
public class Teacher extends Person{
}
package com.oop.demo06;
public class Person {
public void run(){
System.out.println("run");
}
}
package com.oop.demo06;
public class Studenr2 extends Person{
public void go(){
System.out.println("go");
}
}
static 关键字详解
package com.oop.demo07;
//static
public class Student {
private static int age;//静态变量，能被多个类共享，多线程
private double score;//非静态变量
public void run(){//非静态方法可调用静态方法所有东西
go();
}
public static void go(){
}
public static void main(String[] args) {
Student s1 = new Student();
System.out.println(Student.age);//类变量（静态变量推荐用类名.变量，非静态变量（score）不能这样访问）
System.out.println(s1.age);//对象调用变量
System.out.println(s1.score);
new Student().run();//静态方法可调用静态方法，不能调用普通方法（静态与类一起加载，加载之前没有普通类），需要new
Student.go();//go();
}
}
package com.oop.demo07;
public class Person {
{
//2.代码块（匿名代码块）构造器之前，用来赋初始值
System.out.println("匿名代码块");
}
static{
//1.静态代码块，加载初始化数据，与类一起加载，只执行一次
System.out.println("静态代码块");
}
public Person() {//3.构造器
System.out.println("构造方法");
}
public static void main(String[] args) {
Person person1 = new Person();//调用非静态加new
System.out.println("===================");
Person person2 = new Person();//static只执行一次
}
}
package com.oop.demo07;
import static java.lang.Math.random;//静态导入包
import static java.lang.Math.PI;
public class Test {
public static void main(String[] args) {
System.out.println(random());
System.out.println(PI);
}
}
//final修饰类 无父子关系
抽象类
package com.oop.demo08;
//抽象类 本质是类需要继承 extend：单继承 （接口可以多继承）
public abstract class Action {
//只有约束~不写方法体，有人帮我们实现
public abstract void doSomething();//抽象方法，只有方法名，没有方法实现
}
package com.oop.demo08;
//抽象类的所有方法必须要由子类实现，除非子类也抽象，需要子子类实现
public class A extends Action{
@Override
public void doSomething() {
}
}
接口的定义与实现
package com.oop.demo09;
//锻炼抽象思维
//接口 interface定义关键词 接口都需要实现类
public interface UserService{
//接口中所有定义的方法都是抽象的 简写 返回值类型+方法名
void run(String name);//public abstract void run();
void delete(String name);
void update(String name);
void query(String name);
//接口中所有定义的属性都是常量 public static final
int AGE=99;
}
package com.oop.demo09;
public interface TimeService {
void timer();
}
package com.oop.demo09;
//类可以实现接口 implements接口（多个） extends抽象类（单继承）
//实现接口，需要重写接口中方法
public class UserServiceImpl implements UserService,TimeService{//alt+回车
@Override
public void run(String name) {
}
@Override
public void delete(String name) {
}
@Override
public void update(String name) {
}
@Override
public void query(String name) {
}
@Override
public void timer() {//多继承
}
}
接口的作用： 1.约束 2.定义一些方法，让不同的人实现 3.方法都是 public abstract 4.常量都是 public static final 5.接口不能被实例化，接口中没有构造方法（接口不是类，不能new） 6.implements可实现多个接口 7.必须要重写接口中方法N中内部类
成员内部类、静态内部类、局部内部类、匿名内部类
package com.oop.demo10;
public class Outer {
private int id=10;
public void out(){
System.out.println("这是外部类的方法");
}
public class Inner{//加static变静态内部类，与类一起加载
public void in(){
System.out.println("这是内部类的方法");
}
//内部类获得外部类的私有属性
public void ID(){
System.out.println(id);
}
}
public void method(){
class Inner2{ //局部内部类
public void in(){
}
}
}
}
//一个java类中有多个class类，但只能有一个public class类
class A {
public static void main(String[] args) {
}
}
package com.oop.demo10;
public class Test {
public static void main(String[] args) {
new Apple().eat();//没有名字初始化类，不用把实例保存到变量中
new UserService() {//匿名内部类
@Override
public void hello() {
}
};
}
}
class Apple{
public void eat(){
System.out.println("1");
}
}
interface UserService{
void hello();
}
