一、面向对象
物以类聚，分类的思维模式。
面向对象编程：object-oriented programming，oop
面向对象编程的本质：以类的方式组织代码，以对象的组织（封装）数据。
抽象
三大特性：封装、继承、多态
对象是具体的事物。类是抽象的，是对对象的抽象。先有类后有对象，类是对象的模板。
二、方法
方法的定义：修饰符、返回类型、break（跳出switch、结束循环）和return的区别、方法名、参数列表（参数类型、参数名、…）、异常抛出。
package oop.Demo01;
import java.io.IOException;
//Demo01 类
public class Demo01 {
//main方法
public static void main(String[] args){
}
/*
修饰符 返回值类型 方法名（...）{
//方法体
return 返回值；
}
*/
public String sayHello(){
return "hello world";
}
//void 返回为空，直接return；
public void hello(){
return;
}
//return：结束方法，返回一个值或空
public int max(int a,int b){
return a>=b ? a:b;//三元运算符
}
//抛出异常
public void readFile(String file) throws IOException{
}
}
方法的调用：静态方法、非静态方法、形参和实参、值传递和引用传递、this关键字
//第一个class
package oop.Demo01;
public class Demo02 {
public static void main(String[] args){
//直接调用
student.say();
//实例化这个类
//对象类型 对象名=对象值
student stu = new student();
stu.talk();
//或者
new student().talk();
}
}
//第二个class
package oop.Demo01;
//学生类
public class student {
//静态方法 static 和类一起加载的
public static void say(){
System.out.println("学生说话");
}
//非静态方法 不加static 类实例化之后才存在
public void talk(){
System.out.println("学生交流");
}
}
package oop.Demo01;
public class Demo03 {
public static void main(String[] args){
//实参和形参类型一致
int add = Demo03.add(3,6);
System.out.println(add);
}
public static int add(int a,int b){
return a+b;
}
}
值传递
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 Demo05 {
public static void main(String[] args){
Person person = new Person();
System.out.println(person.name);//null
Demo05.change(person);
System.out.println(person.name);//yiyi
}
public static void change(Person person){
person.name = "yiyi"; //person是一个对象，可以改变属性
}
}
//定义一个Person类，有一个属性：name
class Person{
String name;
}
三、类和对象的创建
类是一种抽象的数据类型。
对象是抽象概念的具体实例。
创建和初始化对象：使用new关键字创建对象
//第一段
package oop.Demo02;
//一个项目应该只存在一个main方法
public class Application {
public static void main(String[] args) {
//类是抽象的，需要实例化
//类实例化后会返回一个自己的对象
//student对象就是Student类的具体实例
Student xiaoming = new Student();
Student xiaohong = new Student();
xiaoming.name ="小明";
xiaoming.age = 3;
xiaohong.name ="小红";
xiaohong.age =3;
System.out.println(xiaoming.name); //小明
System.out.println(xiaoming.age); //3
System.out.println(xiaohong.name); //小红
System.out.println(xiaohong.age); //3
xiaoming.study();//小明在学习
}
}
//第二段
package oop.Demo02;
//学生类
public class Student {
//属性：字段
String name;
int age;
//方法
public void study(){
System.out.println(this.name+"在学习");
}
}
四、构造器详解
构造器：1、和类名相同；2、没有返回值
作用：1、new 本质在调用构造器 2、初始化对象的值
注意点：1、定义有参构造之后，如果想使用无参构造，需要显示的定义一个无参构造
this. 代表当前类的。
//第一段
package oop.Demo02;
//一个项目应该只存在一个main方法
public class Application {
public static void main(String[] args) {
//new 实例化一个对象
Person person =new Person("小明");
System.out.println(person.name);//小明
Person per =new Person();
System.out.println(per.name);//一一
}
}
//第二段
package oop.Demo02;
public class Person {
//一个类即使什么都不写，他也会存在一个方法
//显示定义构造器
String name;
//实例化初始值
//1、使用new关键字，必须要有构造器，本质是在调用构造器
public Person(){
this.name ="一一";
}
//有参构造：一旦定义了有参构造，无参就必须显示定义
public Person(String name){
this.name =name;
}
}
五、创建对象内存分析
六、小结类与对象
1、类与对象：类是一个模板：抽象的；对象是一个具体的实例
2、方法：定义、调用。
3、对象的引用：引用类型（八大基本类型）；对象是通过引用来操作的：栈–>堆
4、对象的属性：字段field 成员变量；默认初始化：数字（0/0.0）、char(u0000)、boolean（false）、引用（null）；修饰符 属性类型 属性名=属性值。
5、对象的创建和使用：必须使用new关键字创造对象；构造器；对象的属性；对象的方法
6、类：静态的属性 -->属性；动态的行为–>方法。
七、封装
高内聚：类的内部数据操作细节自己完成，不允许外部干涉
低耦合：仅暴露少量的方法供外部使用
封装（数据的隐藏）：通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。
属性私有，get/set
意义：1、提高程序的安全性，保护数据；2、隐藏代码的实现细节；3、统一接口，规范化；4、提高系统的可维护性。
//第一段
package oop.Demo3;
import javax.xml.soap.SOAPPart;
public class Application {
public static void main(String[] args) {
Student s1 = new Student();
s1.getName();
System.out.println(s1.getName());//null
s1.setName("小明");
System.out.println(s1.getName());//小明
s1.setAge(990);
System.out.println(s1.getAge());//3
}
}
//第二段
package oop.Demo3;
public class Student {
private String name;//private 属性私有
private int id;
private char sex;
private int age;
//提供一些可以操作这个属性的方法
//提供一些public的get、set的方法
//get获得这个数据
public String getName(){
return this.name;
}
//set给这个数据设置值
public void setName(String name){
this.name =name;
}
//commmand+N 直接调出get和set方法
public int getAge() {
return age;
}
public void setAge(int age) {
if(age>120||age<0){
this.age =3;
}else {
this.age = age;
}
}
}
八、继承
关键字extands:子类是父类的扩展
Java中类只有单继承，没有多继承。
//main
package oop.Demo02;
//一个项目应该只存在一个main方法
public class Application {
public static void main(String[] args) {
Student student = new Student();
student.say();
System.out.println(student.getMoney());
}
}
//父类
package oop.Demo02;
//Person:父类
public class Person {
//public 公共的
private int money =1;
public void say(){
System.out.println("说话");
}
//private 私有的
//protected 受保护的
//默认：defaul
public int getMoney() {
return money;
}
public void setMoney(int money) {
this.money = money;
}
}
//子类1
package oop.Demo02;
//Student is a Person：派生类、子类
public class Student extends Person{
}
//子类2
package oop.Demo02;
//Teacher is a Person:派生类、子类
public class Teacher extends Person {
}
九、super
super注意点：
1、super调用父类的构造方法，必须在构造方法的第一个
2、super 必须只能出现在子类的方法或构造方法中
3、super和this不能同事调用构造方法
对比this：
1、代表的对象不同：this本身调用者这个对象、super代表父类对象的应用
2、前提：this没有继承也可以使用、super只能在继承条件下才能使用
3、构造方法：this();本类的构造、super();父类的构造。
//main
package oop.Demo02;
//一个项目应该只存在一个main方法
public class Application {
public static void main(String[] args) {
Student student = new Student();//Person无参执行了 Student无参执行了
student.test("xiao");
}
}
//父类
package oop.Demo02;
//Person:父类
public class Person {
public Person(){
System.out.println("Person无参执行了");
}
protected String name ="小红";
}
//子类
package oop.Demo02;
import java.security.spec.RSAOtherPrimeInfo;
//Student is a Person：派生类、子类
public class Student extends Person{
public Student(){
super();//调用父类的无参构造器，必须要在子类构造器的第一行
System.out.println("Student无参执行了");
}
private String name ="小明";
public void test(String name){
System.out.println(name); //xiao
System.out.println(this.name); //小明，当前类的name
System.out.println(super.name); //小红，父类的name
}
}
十、重写
重写：需要有继承关系，子类重写父类的方法。子类的方法必须和父类一致，方法体不同。
1、方法名必须相同
2、参数列表必须相同
3、修饰符：范围可以扩大public>protected>default>private
4、抛出的异常：范围可以被缩小，但不能扩大：ClassNotFoundException–>Exception(大)
为什么需要重写：
1、父类的功能，子类不一定需要或满足。
command+N：override
package oop.Demo4;
public class Application {
public static void main(String[] args) {
//静态方法：方法的调用只和左边，定义的数据类型有关
//静态方法和非静态方法差别很大
//非静态：重写
A a =new A();
a.test();//A=>test()
//父类的引用指向来子类
B b =new A();//子类重写来父类的方法
b.test();//A=>test()
}
}
//父类
package oop.Demo4;
//重写都是方法的重写，和属性无关
public class B {
public void test(){
System.out.println("B=>test()");
}
}
//子类
package oop.Demo4;
public class A extends B{
//override 重写
@Override//注解：有功能的注释。
public void test() {
System.out.println("A=>test()");
}
}
十一、多态
多态：即同一个方法可以根据发送对象的不同而采用多种不同的行为方式。一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多。
多态存在的条件：有继承关系、子类重写父类的方法、父类引用指向子类对象
注意：多态是方法的多态，属性没有多态性。
十二、instance和类型转换
instanceof（类型转换）引用类型，判断对象是一个什么类型。
System.out.println(x instanceof y);
十三、抽象类
abstract修饰符可以用来修饰方法也可以修饰类。如果用于修饰方法，该方法就是抽象方法；如果用于修饰类，该类就是抽象类。
抽象类的所有方法必须要由继承它的子类实现。
类是单继承的，但是接口可以多继承。
1、不能new抽象类，只能靠子类去实现它：约束！
2、抽象类里面可以写普通方法，抽象方法必须在抽象类中。
十四、接口
interface
作用：
1、约束
2、定义一些方法，让不同人实现
3、接口不能被实例化，接口中没有构造方法
4、implements可以实现多个接口
5、必须重写接口中的方法
扫一扫
3433
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
