1.面向对象 oop
1.面向对象思想
*· 物以类聚，分类的思想模式，思考问题首先会解决问题需要哪些分类,然后对这些分类
进行单独思考.最后.才对某个分类下的细节进行面向过程的思索
*·面向对象适合处理复杂的问题，适合处理需要多人协作的问题
对于描述复杂的事物，为了从宏观上把握，从整体合理分析，我们需要使用面向对象的思路来分析整个系统.但是具体到微观操作，仍然需要面向过程的思路去处理
面向对象编程的本质就是：以类的方式组织代码，以对象的组织(封装)数据.
抽象
三大特性
*封装
*继承
*多态
从代码运行角度考虑是先有类后有对象. 类是对象的模板.
package 面向对象;
//oop 类
public class oop1 {
public static void main(String[] args) {
int max=max(10,20);
System.out.println(max);
}
/*
* 修饰符 返回值 方法名(...){
* 方法体
* return 返回值;
* }
*/
public String Hello(){
return "Hello";
}
public static int max (int a , int b ) {
if (a>b){
return a;
} else return b;
}
} // void 返回值为空
1.调用
静态方法可以直接调用 类名. 方法名
1.非静态
如果他俩同为 static可以调用
如果一个是static 一个 不是static 则不可以调用
static是和类一起加载的 B 是实例化之后才存在的
2.形参和实参
package 面向对象;
public class oop3 {
public static void main(String[] args) {
int sum= (int) sum(20,30);
//实际参与的数字就是实参
System.out.println(sum);
}
public static double sum (int C , int D) {
//形式设计的 数值就是形式参数
return C+D;
}
}
3.值传递
package 面向对象;
//值传递
public class oop4 {
public static void main(String[] args) {
int a = 1;
System.out.println(a);
oop4.change(a);
System.out.println(a);
}
public static void change(int a) {
a =10;
}
}
4.引用传递**
package 面向对象;
//引用传递：对象 ，本质还是直传递
public class oop5 {
public static void main(String[] args) {
Person person = new Person();
System.out.println(person.name);//null
oop5.change(person);
System.out.println(person.name);//小学生
}
public static void change(Person person) {
person.name ="小学生";
}
}
//定义一个person类， 有一个属性：name
class Person{
String name;
}
2.类和对象的关系
1.类是一种抽象的数据类型，它是对某一类事物整体的描述/定义，但是并不能代表某一具体的事物
2.对象是抽象概念的具体实例
能够体现出特点，展现出功能的是具体的实列，而不是一个抽象的概念
1.创建与初始化对象
1.使用 new 关键字创建对象
2.使用new关键字创建是时候，除了分配内存空间之外，还会给创建好的对象 进行默认的初始化 以及对类中构造器的调用
3.类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的.并且构造器有以下两个特点.
1.必须和类的名字相同
2.必须没有返回类型， 也不能写void
package 面向对象;
//一个项目只能处在一个mian方法
public class Application {
public static void main(String[] args) {
// 类：抽象的 ，实例化
// 类实列化后会返回一个自己的对象！
//student对象就是一个Student类的具体实列
Student xiaohong = new Student();
Student xiaoming = new Student();
//student 他是一个类 不是具体的一个值
xiaoming.name="小明";
xiaoming.age=10;
System.out.println(xiaoming.name);
System.out.println(xiaoming.age);
}
}
package 面向对象;
//学生类
public class Student {
//属性 ：字段
String name;//默认值 null //是一个抽象的概念一个模板
int age; //默认值 为0 //是一个抽象的概念一个模板
//方法
public void student(){
System.out.println(this.name + "学生说话了");
}
}
2.构造器
无参构造
先走new persion 在走public persion ---- this name ----在返回 给name
有参构造
new persion 定义了一个name 就走有参构造
Alt+ insert 生成构造器
构造器 ：
1.和类名相同
2.没有返回值
作用 ：
1.new 本质在调用构造器
2.初始化对象的值
注意点
1.定义有参构造器之后，如果想使用无参构造，显示的定义一个无参的构造
this. 标识这个类
后面this.= 什么 表示传进来的
3.创建对象内存分析
4.封装
高内聚 低耦合
高内聚：就是类的内部数据作细节自己完成，不允许外部干涉
低耦合：仅暴露少量的方式给外部使用
封装
通常，应禁止直接访问一个对象中数据的实际表示 ，而应通过操作访问，这称为信息隐藏
属性私有
get / set
get
set
ALT + insert 只动生成get set 方法
封装的意义
1.提高程序的安全性，保护数据
2.隐藏代码的实现细节
3.统一接口
4.增加了系统可维护
package 面向对象;
public class Application {
public static void main(String[] args){
Student student = new Student();
student.getName();
student.setName("小学生");
System.out.println(student.getName());
student.getAge();
student.setAge(70);
System.out.println(student.getAge());
}
}
package 面向对象;
//学生类
public class Student {
//private 属性私有
private String name;
private int age;
private int ID;
//提供一些 可以操作这个属性的方法
//提供一些 public 的get . set 方法
// get 获得这个数据
public String getName() { //获取值不能用void
return this.name;
}
// set 给这个数据设置值
public void setName(String name){
//括号里要有调用的形势参数
this.name=name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
if (age>120 || age<0){
System.out.println("年龄不合法");
}else
this.age = age;
}
}