面向对象
-
面向对象思想
- 物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考。最后才对某个分类下的细节进行面向过程的思索
- 面向对象适合处理复杂的问题，适合处理需要多人协作的问题
-
面向过程
- 步骤清晰简单，第一步做什么，第二步做什么
- 面对过程适合处理一些较为简单的问题
-
对于描述复杂的事物，为了从宏观上把握、从整体上合理分析，我们需要使用面向对象的思路来分析整个系统。具体到围观操作，仍需要面向过程的思路去分析
-
面向对象编程的本质：以类的方式组织代码，以对象的组织（封装）数据。
-
抽象
-
三大特性：
- 封装
- 继承
- 多态
-
从认识论角度考虑是现有对象后有类。对象，是具体的事物。类，是抽象的，是对对象的抽象
-
从代码运行角度考虑是先有类后有对象。类是对象的模板
方法*
-
方法的定义
//Demo01就是一个类 public class Demo01 { //main方法 public static void main(String[] args) { } /* 修饰符 返回值类型 方法名（。。。）{ //方法体 return 返回值 } */ //return 结束方法，返回一个结果 public String sayHello(){ return "Hello World!"; } } -
方法调用
-
静态与动态方法
- 由于static修饰（静态）的表示属于类，因此如果想访问类的方法或者遍历，则可以直接通过类名.方法名() / 类名.变量名 进行访问
- 所谓的动态和静态的区别：对于一个类来说，如果没有被static所修饰的变量或者成员方法，那么每实例一个新的对象（new），这些非static修饰的都属于对象
public class Demo02 { public static void main(String[] args) { //静态方法 static say(); //非静态方法 Student stu = new Student(); stu.hello(); } } -
形参和实参
- 形参变量只有在被调用时才分配内存单元，在调用结束时，即刻释放所分配的内存单元。因此，形参只在函数内部有效。函数调用结束返回主调用函数后则不能再使用该形参变量。
- 实参可以是常量、变量、表达式、函数等，无论实参是何种类型的量，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形参。因此应预先用赋值，输入等办法使参数获得确定值。
-
值传递和引用传递
这里借一下大佬的笔记，就不一一去记录了。链接地址
-
类与对象
- 类是一种抽象的数据类型，它是对某一类事物整体藐视/定义，但是并不能代表某一个具体的事物。
- Person类、Pet类、Car类等，这些类都是用来描述/定义某一类具体的事物应该拒北的特点和行为
- 对象是抽象概念的具体实例
- 张三就是人的一个具体实例，张三家里的旺财就是狗的一个具体实例
- 能够体现出特点，展现出功能的是具体的实例，而不是一个抽象的概念。
- 创建与初始化对象
- 使用new关键字创建对象
- 使用new关键字创建的适合，除了分配内存空间之外，还会给创建号的对象，进行默认的初始化以及对类中构造器的调用
//一个项目应该只存在一个main方法
public class Application {
public static void main(String[] args) {
//类：抽象的，实例化
//类实例化后会返回一个自己的对象，student对象就是一个Student类的具体实例
Student XiaoMing = new Student();
Student XiaoHong = new Student();
XiaoMing.name = "小明";
XiaoMing.age=21;
XiaoHong.name = "小红";
XiaoHong.age=21;
System.out.print("我叫"+XiaoMing.name+"今年"+XiaoMing.age);
XiaoMing.study();
System.out.println("我叫"+XiaoHong.name+"今年"+XiaoHong.age);
}
}
class Student {
//数学：字段
String name;
int age;
//方法
public void study(){
System.out.println(this.name+"在学习");
}
}
-
类中的构造器也称为构造方法，是在进行创建对象的适合必须要调用的。并且构造器有两个特点：
-
必须和类的名字相同
-
必须没有返回类型，也不能写void
-
在你创建了一个类时，他默认会有一个无参的空的构造器，在你创建有参的构造器后，他就会失去，所以无参就必须显示定义，一般我们可以在创建构造器的时候，将无参的构造器先创建可以为空。
-
使用new关键字本质上是在调用构造器
public class Person { String name; int age; public Person(){ } public Person(String name){ this.name = name; } public Person(String name,int age){ this.name = name; this.age=age; } }//一个项目应该只存在一个main方法 public class Application { public static void main(String[] args) { Person per1=new Person(); Person per2=new Person("煎饼"); Person per3=new Person("煎饼",21); System.out.println("无参是："+per1.name+" "+per1.age); System.out.println("有参是："+per2.name+" "+per2.age); System.out.println("多参是："+per3.name+" "+per3.age); } }
-
通过以上代码，可以总结出，在new一个对象的时候，根据你的参数个数，会选择对应的构造器，完成对应的构造器内容的初始化。
注意点：定义有参构造后，如果想要使用无参构造，需要显示的定义一个无参的构造
-
堆&栈 （后期理解清楚再详细写一篇）
封装
-
该露的露，该藏的藏
-
程序设计要追求“高内聚，低耦合”。高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用。
-
封装（数据的隐藏）
- 通常，应禁止直接访问一个对象中数据的实际表示，而是通过操作接口来访问，这称为信息隐藏。
- private：私有。带private修饰符的属性或者方法外部是无法直接进行调用的。
- alt+insert，快捷创建get/set方法
//类 private：私有 public class Student { //属性私有 private String name;//名字 private int id;//学号 private char sex;//性别 private int age;//年龄 //因为属性是私有的，外部无法直接进行调用，需要通过方法来进行对私有属性的修改 public int getAge() { return age; } public void setAge(int age) { this.age = age; } public String getName() { return name; } public void setName(String name) { this.name = name; } 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 class Application { public static void main(String[] args) { Student stu1 = new Student(); stu1.setName("煎饼"); stu1.setId(1); stu1.setSex('男'); stu1.setAge(18); System.out.println("我是"+stu1.getName()+stu1.getId()+"号，性别"+stu1.getSex()+"，现在"+stu1.getAge()); } }-
我们可以再set方法里面去做限制，例如年龄肯定是没有小于0或是几百岁的，又或者性别一般来说只有男和女。在set接收数据的时候做一个判断。
public void setAge(int age) { if(age<0 || age>120){//做一个判断，它是否是一个正常的年龄 this.age=0; }else{ this.age = age; } } -
封装就如同我们电脑一般，他就是封装好的，只留下了一些接口（I/o设备）以提供我们操作，而不是让我们去直接对电路进行修改。
继承①
- 继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模
- extends的意思是“扩展”。子类是父类的扩展
- JAVA中类只有单继承，没有多继承！
- 继承是类和类之间的一种关系。除此之外，类和类之间的关系还有依赖、组合、聚合等。继承关系的两个类，一个为子类（派生类）一个为父类（基类）。子类继承父类，使用关键字extends来表示。
父类
public class Person {
public int money01=10_000_000;//公共
private int money02 = 1000;//私有
public void say(){
System.out.println("Hello my dear son!");
}
public int getMoney02() {//私有属性，需要通过公开的方法进行操作
return money02;
}
public void setMoney02(int money02) {
this.money02 = money02;
}
}
子类，直接继承父类的内容，可以使用父类的一些方法以及属性，这里为了直观直接为空
public class Teacher extends Person{
}
主程序
public class Application {
public static void main(String[] args) {
Student student = new Student();
System.out.println(student.money01);
student.say();
System.out.println(student.getMoney02());//我使用了方法才拿到了这笔钱
}
}
在主程序中，创建对象，然后调用属性和方法时，可以看到，找不到money02，因为该属性私有，只能通过方法去访问，或者访问不了。（上节封装的知识点），通过创建get/set方法可以对私有属性进行操作。
-
子类继承了父类，就会拥有父类的全部方法
-
public公共类，可以被所有其他类所访问。相当于这是遗产，儿子能直接继承使用
-
protected，自身、子类及同一个包中类可以访问。
-
default，默认：同一包中的类可以访问，声明时没有加修饰符，认为是friendly。
-
private私有类，只能被自己访问和修改。可以通过靠方法来调用，这相当于是爸爸的私房钱，需要一定的方法才能获得使用，或是无法使用
-
ctrl+h可以查看继承结构
- 可以看到Student继承Person，但是Person我们没有设置继承父类，结构上却显示继承了Object；因为所有类，默认都会继承一个Object类。
继承 ②
-
super与this
-
代表的对象不同
this：本身调用者这个对象
super：代表父类对象的应用
-
前提
this：没有继承也可以使用
super：只能在继承条件下使用
-
构造方法
this（）：本类的构造方法
super（）：父类的构造方法
-
-
我们还是用代码运行结果，进行理解
主程序
public class Application {
public static void main(String[] args) {
Student stu1 = new Student();//再创建对象时调用无参构造器
System.out.println("****************************");
stu1.test("小明");//调用子类test方法
System.out.println("****************************");
stu1.test1();//调用子类test1方法
}
}
父类
public class Person {
public Person(){//为了更加明显的看到运行结果，我们自行创建一个无参构造器
System.out.println("Person父类的无参调用");
}
String name = "jianbing";
public void print(){
System.out.println("Person");
}
}
子类
public class Student extends Person{
public Student(){//为了更加明显的看到运行结果，我们自行创建一个无参构造器
System.out.println("Student子类的无参调用");
}
private String name = "煎饼";
public void test(String name){
System.out.println(name);//传进来的参数
System.out.println(this.name);//子类的属性
System.out.println(super.name);//父类的属性
}
public void test1(){
print();//本类的方法
this.print();//本类的方法
super.print();//父类的方法
}
public void print(){
System.out.println("Student");
}
}
运行结果
- 在创建对象的时候，可以看到父类的无参构造器也进行了构造：
- 在子类的构造器中，隐藏了调用父类无参构造的代码，在子类构造前，除非在构造器中自行选择了父类的有参构造方法，默认都是调用父类的无参构造方法。
- 因为父类要先完成构造，所以在子类构造前，先进行父类构造
- this，表示的都是本类的属性或者方法，super使用的都是父类；
- 在子类中与父类有同个方法名时，这边建议使用this和super，用this表示本类，这样程序结构能更加清晰。
3546
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
