JavaSE基础篇---oop:面对对象
//有些杂，，，，看不懂可以找我，我再重写
类，方法的调用
package com.oop.demo01; //类，方法的调用 public class Demo01 { public static void main(String[] args) { //静态调用,在之前的随笔里有记载 //Student.say(); //动态态调用 Student student = new Student(); student.say(); } //和类一起加载的 public static void a(){ } //类实例化之后才存在的，所以静态方法和动态方法不能混合调用 public void b(){ } }
值传递
package com.oop.demo01; import java.util.Date; //值传递 public class Demo02 { public static void main(String[] args) { int a=1; System.out.println(a);//1 Demo02.change(a); //change（a）没有把a处理后的值返回所以结果依旧是1 System.out.println(a);;//1 } //返回值为空 public static void change(int a){ a=10; } }
引用传递
package com.oop.demo01; //引用传递：对象，本质还是值传递 //注意：对象，内存 public class Demo03 { public static void main(String[] args) { Person person = new Person(); System.out.println(person.name);//null Demo03.change(person); System.out.println(person.name);//king } public static void change(Person person){ //person是一个对象： person.name="king"; } } //定义一个Person类，有一个熟悉属性：name class Person{ String name; }
有参无参
package com.oop.demo02; //java——》class //out目录就是输出文件，将java文件变成class public class Person { //一个类即时什么都不写，class里也会有一个默认的方法（构造器） String name; int age; //实例化初始值 //1.使用new关键字，本质是在调用构造器 //无参构造 public Person(){ this.name="king"; } //有参构造.一旦定义有参构造，无参就必须显示定义 public Person(String name){ this.name=name; } public Person(String name,int age){ this.name=name; this.age=age; } } /* public static void main(String[] args) { Person person = new Person("king",23); System.out.println(person.name); } 构造器: 1.和类名相同 2.没有返回值 作用： 1.new本质在调用构造方法 2.初始画对象的值 注意点： 1.定义有参构造之后，如果想用无参构造，显示的定义一个无参的构造 ait+insert自动生成方法 * */
package com.oop.demo02; public class Student { //属性：字段 String name; int age; //方法 public void study(){ System.out.println(this.name+"在学习"); } } //练习 /* public static void main(String[] args) { //类：抽象的，要实例化 //类实例化后会返回自己的对象 //student对象就是一个Student类的具体的一个实例 Student gg=new Student(); Student mm=new Student(); gg.name="小g"; gg.age=9; gg.study();//小g在学习 System.out.println(gg.name);//小g System.out.println(gg.age);//9 mm.name="小m"; mm.age=3; System.out.println(mm.name);//小m System.out.println(mm.age);//3 } * */
创建对象
package com.oop.demo03; //创建对象 public class Pet { public String name; public int age; public void shout(){ System.out.println("king"); } } /* 小结 1.类与对象 类是一个模板：抽象，对象是一个具体的实例 2.方法 定义，调用 3.对应的引用 引用类型：基本类型（8） 对象是通引用来操作的：栈——》堆 4.属性：字段Field 成员变量 默认初始化： 数字：0/0.0 char：u0000 boolean： false 引用：null 5.对象的创建和使用： 你须使用new关键字，构造器 eg:Person king=new Peeson() 对象的属性：king.name 对象方法：king.sleep() 6.类： 静态的属性 属性 动态的行为 方法 封装，继承，多态 * public static void main(String[] args) { Pet dog = new Pet(); dog.name="cai"; dog.age=3; dog.shout(); System.out.println(dog.name); System.out.println(dog.age); }*/
封装
package com.oop.demo04; //封装： //意义：提高程序的安全性，保护数据 // 隐藏代码的实现细节 // 统一接口 // 提高系统可维护性 //封装本质： //类 private：私有 ，get，set public class Student { private String name; //名字 private int id;//学号 private char sex;//性别 private int age;//年龄 //提供可以操作private的方法 //解决：get，set方法 //get 获得数据 public String getName(){ return this.name; } //set方法，给数据设置值 public void setName(String name){ this.name=name; } //alt+insert自动生成方法 public int getId() { return id; } public void setId(int id) { this.id = id; } public char getSex() { return sex; } public void setSex(char sex) { this.sex = sex; } public int getAge() { return age; } public void setAge(int age) { if(age<120&&age>=0){ this.age = age; }else{ this.age=3; } } } /* public static void main(String[] args) { Student s1=new Student(); s1.setName("king"); s1.setAge(70); System.out.println(s1.getAge()); } */
继承
package com.oop.demo05; //继承 public class A extends B{ @Override//注解：重写 public void test() { System.out.println("A=》test"); } } package com.oop.demo05; //重写都是方法的重写，和属性无关 public class B { public void test(){ System.out.println("B=>test()"); } } /* * public static void main(String[] args) { //静态方法和非静态方法区别很大 A a = new A(); a.test();//A //父类的引用指向了子类 B b=new A();//子类重写了父类的方法 b.test();//A } 小结： 重写：需要有继承关系，子类重写父类方法 1.方法名必须相同 2.参数列表必须相同 3.修饰符：范围可以扩大但不能缩小：public>protected>Default>private 4.抛出异常：范围，可以被缩小，但不能扩大： 为什么重写： 1.父类功能：子类不一定需要，或不一定满足 Alt+Insert：override * */ //Person是父类 Student和Teacher是子类 package com.oop.demo05; //在Java中，所有的类，都直接或间接默认继承object //extends:扩展 //父类 public class Person /*extends Object*/ { public String name="kings"; public Person() { System.out.println("Person无参执行了"); } } /* //public //proteced受保护的 //default 默认的 //private 私有的 //优先级高——>低 private int money=10_0000_0000; public void say(){ System.out.println("king"); } public int getMoney() { return money; } public void setMoney(int money) { this.money = money; } super注意点： 1.super调用父类的构造方法，必须在构造方法发的第一个 2.super必须只能在现在子类的方法或者构造方法中 3.super和this不能同时调用构造方法 与this对比 代表的对象不同 this：本身调用者这个对象 super：代表父类对象应用 前提 this：没有继承也可以使用 suo：只能在继承条件下才可以使用 构造方法 this();本类的构造 super（）；父类构造 */ package com.oop.demo05; //Student类是Person类的派生类，子类 //子类继承了父类，就会拥有父类的全部方法 public class Student extends Person { //Ctrl+H; public Student(){ //隐藏代码：调用了父类的无参构造 //super();调用父类构造器必须放到子类构造器的第一行 System.out.println("Student 无参执行了"); } private String name="king"; public void test1(){ System.out.println(name);//kingking System.out.println(this.name);//king,this输出当前类的值 System.out.println(super.name);//kings，super父类的值 } public void test(String name){ System.out.println(name);//kingking System.out.println(this.name);//king,this输出当前类的值 System.out.println(super.name);//kings，super父类的值 } } /* public static void main(String[] args) { Student student = new Student(); //student.test("kingking"); } * */ package com.oop.demo05; public class Teacher extends Person { }
多态
package com.oop.demo06; public class Person { public void run(){ System.out.println("run"); } } /* 多态注意事项 1.多态是方法的多态，属性没有多态 2.父类和子类，有联系 类型转换异常！ClassCastException！ 3.存在条件：继承关系，方法需要重写，父类引用指向子类对象 1.static 方法，属于类，它不属于实例 2.final 常量： 3.private 方法： 以上3个都不能重写 * */ /* public static void main(String[] args) { //一个对象的实际类型是确定的 //new Student(); //new Person(); //可以指向的引用类型就不确定 //Student 能调用的方法都是自己的，或者从父类继承的 Student s1 = new Student(); //Person 父类型，可以指向子类，但不能调用子类特有的方法 Person s2=new Student(); Object s3 = new Student(); s2.run(); s1.run(); } */ package com.oop.demo06; public class Student extends Person { @Override public void run() {//子类重写父类方法 System.out.println("son"); } public void eat(){ System.out.println("ear"); } }
instanceof，强制转换
//person 父类 stud和teache子类 package com.oop.demo07; //instanceof，强制转换 public class Person { public void run(){ System.out.println("run"); } } /* public static void main(String[] args) { //Object>String //Object>Person>Teacher //Object>Person>Student Object object = new Student(); //System.out.println(X instanceof Y);//能不能编译通过 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 System.out.println("=========="); Person person=new Student(); 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);//编译报错，person与String没有关系 } /* 1.父类引用指向子类对象 2.把子类转换为父类，向上转型：丢失精度，可能丢失一些方法 3.把父类转换为子类，向下转型：强制转换eg:Person obj=new student; ((student)obj).go(); * */ package com.oop.demo07; public class Student extends Person { } package com.oop.demo07; public class Teacher extends Person { }
导包
package com.oop.Demo08; //静态导入包 import static java.lang.Math.random; //static public class Student { private static int age;//静态的变量,多线程用到！ private double score;//非静态变量 public static void main(String[] args) { Student s1 = new Student(); System.out.println(Student.age);//0 System.out.println(s1.age);//0 System.out.println(s1.score);//0.0 } }
抽象类 ，关键词abstract
package com.oop.demo09; //抽象类的所有方法，继承了它的子类，都必须要实现他的方法，除非他也是抽象类 public abstract class A extends Action{ public void doSomething() { } } package com.oop.demo09; //abstract 抽象类；类 extends: 单继承（类只有单继承），接口可以多继承 public abstract class Action { //约束~有人帮我们是实现 //abstract,抽象方法，只有方法名字，没有方法实现！ public abstract void doSomething(); } //抽象类特点：不能new这个抽象类，只能靠子类去实现它：约束！ // 抽象类中可以写普通的方法 // 抽象方法必须在抽象类中 // 抽象的抽象：约束~ //思考？ //1.可以new对象吗，存在构造器吗？ //2.存在意义 抽象出来~提高开发效率 //思考题解答 //1.抽象类是存在构造函数的，其构造函数是提供给子类创建对象的时候初始化父类的属性的。 //2.更利于代码的维护和重用，对子类进行保护，当你修改子类数据时触发到抽象类，会提醒开发者有些东西不可随意改变
接口，关键此interface
package com.oop.Demo10; public interface TimeService { void timer(); } package com.oop.Demo10; //抽象的思维~Java！！！ //接口:interface,关键字 //接口都需要有实现类 public interface UserService { //接口中的所有定义都是抽象的 public //常量,一般不会用 public static final int AGE=99; void add(String name); void delete(String name); void update(String name); void query(String name); } /* 接口作用： 1.约束 2.定义一些方法，让不同的人实现 3.方法：public abstract 4.常量：public static final 5.接口不能被实例化，接口中没有构造方法 6.implements可以实现多个接口；eg：public class UserServiceImpl implements UserService,TimeService{} 7.实现接口，必须要实现重写接口中的方法 **/ package com.oop.Demo10; //类 可以实现接口 implements 接口 //实现接口的类，就需要重写接口的方法 public class UserServiceImpl implements UserService,TimeService{ @Override public void add(String name) { } @Override public void delete(String name) { } @Override public void update(String name) { } @Override public void query(String name) { } @Override public void timer() { } }
