m0_56021431的博客

package OOP.Demo11;public class Outer {public void method(){class inner{public void in(){ } }}}//一个java类中可以有多个class类,但是只能有一个public class类class A{public static void main(String[] args) {} }/*private int id=10;public void out(){

package OOP.Demo11;public class Test {public static void main(String[] agrs){//没有名字初始化类,不用将实例保存到变量中new Apple().eat();UserService userService= new UserService(){ @Override public void hello() { } };}}class Apple{publi

package OOP.Demo10;//抽象类: extends~//类 可以实现接口 implements 接口//实现了接口的类,就需要重写接口中的方法~public class UserServiceImpl implements UserService,TimeService {@Overridepublic void run(String name) {}@Overridepublic void delete(String name) {}@Overridepub

Demo09//interface 定义的关键字 接口都需要实现类public interface UserService {//常量~ public static finalint AGE=99;//接口中所有定义其实都是抽象的 public abstractvoid run(String name);void delete(String name);void update(String name);void query(String name);}...

Demo09作用:1.约束2.定义一些方法3.public abstract4.public static final5.接口不能被实例化,接口中没有构造方法6.implements可以实现多个接口7.必须要重写接口中的方法8.总结博客

package OOP.Demo09;//抽象类的方法继承了它的子类,都必须要实现它的方法~ 除非~public class A extends Action {@Overridepublic void dosomething() {}}

package OOP.Demo09;import java.util.concurrent.ArrayBlockingQueue;//abstract 抽象类: 类 extends: 单继承~ (接口可以多继承)public abstract class Action {//约束~有人帮我们实现~//abstract ,抽象方法,只有方法名字,没有方法实现.public abstract void dosomething();//1.不能new这个抽象类,只能靠子类去实现它: 约束!//

Demo08package OOP.Demo08;//静态导入包import static java.lang.Math.random; // 设置一次之后,就不用每次都需要类名前缀了public class Test {public static void main(String[] args) {System.out.println(Math.random()); System.out.println(random()); //不用类名,直接使用随机数,}}...

Demo08package OOP.Demo08;public class Student {private static int age; //静态的变量private double score; //非静态变量public void run(){ go();}public static void go(){}public static void main(String[] args) { go(); /* Student s1 = new Stu

Demo08package OOP.Demo08;public class Person {//2 : 赋初值~{//代码块 (匿名代码块)System.out.println(“匿名代码块”);}//1: 只执行一次~static { //静态代码块 System.out.println("静态代码块");}//3public Person(){ System.out.println("构造方法");}public static void mai

Demo08package OOP.Demo07;public class Student extends Person{public void go(){ System.out.println("go");}}/* //类型之间的转化: 父 子 //高 低 Person obj = new Student(); //student 将这个对象转换为Student 类型,我们就可以使用Student类型的方法了!

Demo06package OOP.Demo06;public class Student extends Person{@Overridepublic void run() { System.out.println("son");}public void eat(){ System.out.println("ear");}}

Demo06package OOP;import OOP.Demo06.Person;import OOP.Demo06.Student;//静态的方法和非静态的方法区别很大!//静态方法://方法的调用只和左边,定义的类型有关//非静态:重写public class Application {public static void main(String[] args) { // 一个对象的实际类型是确定的 // new Student(); // new Perso

Demo06package OOP.Demo06;import org.w3c.dom.ls.LSOutput;public class Person {public void run(){ System.out.println("run");}}/*多态的注意事项:1.多态是方法的多态,属性没有多态2.父类和子类,有联系 类型转换异常! ClassCastException!3.存在条件: 继承条件: 方法需要重写,父类引用指向子类对象! father f1=new so

Demo05package OOP.Demo05;//学生 is 人:派生类 ,子类//子类继承了父类,就会拥有父类的全部方法!public class Student extends Person {//隐藏代码:调用了父类的无参构造//super(); //调用父类的构造器,必须要在子类构造器的第一行public Student(){System.out.println(“Student无参执行了”);}private String name="qinjiang";publi

Demopublic class Person {public Person(){System.out.println(“Person无参执行了”);}protected String name="kuangshen";//私有的东西无法被继承!public void print(){System.out.println("Student");}}/*//public//protected//default//privateprivate int money=10_0

Demo05package OOP.Demo05;//重写都是方法的重写,和属性无关public class B {public void test(){ System.out.println("B=>test()");}}

Demo05package OOP.Demo05;//继承public class A extends B {//Override 重写@Override //注解: 有功能的注释public void test() { System.out.println("A=>test()");}}

Demo05super 注意点:1.super调用父类的构造方法,必须在构造方法的第一个2.super 必须只能出现在子类的方法或者构造方法中3.super和this不能同时调用构造方法!Vs this:代表的对象不同:this:本身调用者这个对象super:代表父类对象的应用前提this: 没被继承也可以调用super:只能在继承条件才可以使用构造方法this(); 本类的构造super(): 父类的构造重写:需要有继承关系,子类重写父类的方法!1.方法名必须相同2.参数

Demo04package OOP.Demo04;//类 private:私有public class Student {//属性私有private String name; //名字private int id; //学号private char sex; //性别private int age; //年龄//提供一些可以操作这个属性的方法!//提供一些public 的get,set方法//get 获得这个数据public String getName(){ ret

package OOP.Demo03;public class Pet {public String name;public int age;public void shout(){ System.out.println("叫了一声");}}/*package OOP.Demo03;public abstract class Application {public static void main(String[] args) {Pet dog = new Pet();dog.

/*1.类与对象 类是一个模板:抽象,对象是一个具体的实例2.方法 定义,调用!3.对应的引用 引用类型: 基本类型(8) 对象是通过引用来操作的: 栈--->堆 4.属性:字段Field 成员变量 默认初始化: 数字: 0 0.0 char: u0000 boolean: false 引用: null

package OOP.Demo02;//学生类public class Student {//属性: 字段String name;int age;//方法public void study(){ System.out.println(this.name+"学生在学习");}}

package OOP.Demo02;public class Person {//一个类即使什么都不写,它也会存在一个办法//显示的定义构造器String name;int age;//Alt+Insert 构造生成快捷键//1.使用new关键字,本质是在调用构造器//2.用来初始化值public Person (){ this.name="qinjiang";}//有参构造:一旦定义了有参构造,无参就必须显示定义 public Person(String na

package OOP.Demo01;//引用传递:对象,本质还是值传递//对象,内存!public class Demo05 {public static void main(String[] args) {Perosn perosn = new Perosn();System.out.println(perosn.name); //nullDemo05.change(perosn);System.out.println(perosn.name); //老师}public stati

package OOP.Demo01;//值传递public class Demo04 {public static void main(String[] args) {int a=1;System.out.println(a);Demo04.change(a);System.out.println(a);}//返回值为空public static void change(int a){ a=10;}}

package OOP.Demo01;public class Demo03 {public static void main(String[] args) {//实际参数和形式参数的类型要对应!int add=Demo03.add(12,13);System.out.println(add);}public static int add(int a,int b){ return a+b;}}

package OOP;public class Demo02 {public static void main(String[] args) {//和类一起加载的public static void a(){// b();} //类实例化 之后才存在 public void b(){ } }}

package OOP;//Demo01 类public class Demo01 {//main 方法public static void main(String[] args) {}/*public 修饰符 公共的,所有人都可以访问String 返回的类型 字符串sayHello 方法名return 返回的内容修饰符 返回值的类型 方法名(...){// 方法体return 返回值;} */public String sayHello(){ return