标签：Day08 java 对象 void System println new public out
面向对象
面向对象和面向过程
- 面向过程思想：
- 步骤清晰简单，第一步...,第二步...
- 面向过程适合处理一些较为简单的问题
- 面向对象思想：
- 物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对分类进行单独思考。最后，才对每个分类下的细节进行面向过程的思索
- 面向对象适合处理复杂的问题，适合处理需要多人协作的问题
- 对于描述复杂的事物，为了从宏观上把握，从整体上合理分析，我们需要使用面向对象的思路来分析整个系统。但是具体到微观操作，仍然需要面向过程的思路去处理。
什么是面向对象
- 面向对象编程（Object-Oriented Programming,OOP)
- 面向对象编程的本质就是：以类的方式组织代码，以对象组织（封装）数据。
- 抽象（对象：现实物体，类：按从多个对象中抽象的共同属性划分对象整体）
- 三大特征：
- 封装
- 继承
- 多态
- 从认识论的角度考虑是先有对象再有类。对象是具体的事物，类是对对象的抽象。
- 从代码运行的角度考虑是先有类后有对象，类是对象的模板。
public class Demo01 {
public static void main(String[] args){
//非静态方法调用需要实例化这个类
//实例化：对象类型（类名） 对象名 =对象值
Student student = new Student();
student.say();
}
//修饰符 返回值类型 方法名
//return：方法结束，break：循环结束
public static String sayhello(){
return "hello world";
}
//静态方法内不可直接调用非静态方法，static随着类产生，非静态方法随着对象产生，先产生的不可调用后产生的，只能通过对象调用
public static void a(){
Demo01 demo01 = new Demo01();
demo01.b();
}
//实例化之后才存在
public void b(){
}
}
public class Student {
public void say(){
System.out.println("speak");
}
}
-
引用传递和值传递
//引用传递（对象的值传递） public class Demo04 { public static void main(String[] args) { Person person = new Person();//创建一个Person类的实例对象person System.out.println(person.name);//null（初始值） change(person);//改变实例对象person的name属性 System.out.println(person.name);//jiang可以改变成功 } public static void change(Person person){//改变对象的属性 person.name = "jiang"; } } class Person{//创建一个Person类，定义一个属性：name String name;//初始值为null }//值传递 public class Demo03 { public static void main(String[] args) { int a = 1; System.out.println(a);//1 Demo03.change(a); System.out.println(a);//1 } public static void change(int a){ a = 10; }//10 }
类与对象的关系
- 类是一种抽象的数据类型，它是对某一类事物的整体描述/定义，但并不能代表某一个具体的事务
- 生物creature，手机，电脑......
- Person类，Pet类，Car类，这些类都是用来描述/定义某一类具体事务应该具备的特点和行为。
- 对象是抽象概念的具体实例
- 张三就是人的一个具体实例，张三家的狗旺财就是狗的一个具体实例。
- 能够体现出特点，展现出功能的是具体的实例，而不是一个抽象的概念。
创建和初始化对象
- 使用new关键字创建对象
- 使用new关键字创建的时候，除了分配内存空间外，还会给创建好的对象进行默认的初始化以及对类中构造起的调用
- 类中的构造器也叫构造方法，是在创建对象时必须要调用的。并且构造器有以下两个特点：
- 必须和类的名字相同
- 必须没有返回类型，也不能写void
public class Person {
//一个类即使什么都不写也会存在一个（构造）方法
//显式定义一个构造器
String name;
//使用new关键字，本质上是在调用构造器
//用来初始化值
public Person() {
}
//有参构造
//一旦定义了有参构造无参构造就必须显式定义
//有参=无参方法的重载
public Person(String name) {
this.name = name;//当前类的name=方法传入的name
}
}
/*
构造器：
1.和类名相同
2.没有返回值
作用：
1.new本质是在调用构造方法
2.初始化对象的值
注意点：
1.定义有参构造之后，如果想使用无参构造，需要显式的定义一个无参构造
2.this.name=name;当前类的属性（name)=方法传入的name
Alt + insert：创建构造器的快捷方法
*/
public class Student {
//属性：字段
//是Student类的模板，具体的对象才有具体的值
String name;
int age;
//方法
public void study(){
System.out.println(this.name + "在学习");
}
}
/*
类---->属性---->具体对象
人类--->身高体重，年龄，国籍...--->确定具体的人
*/
-
创建对象的内存分析
封装，继承，多态
1.封装
-
该漏的漏，该藏的藏
- 我们设计程序应该追求“高内聚，低耦合”，高内聚就是类的内部数据操作自己完成，不允许外部干涉，低耦合：仅暴露少量的方法给外部使用。
-
封装（数据的隐藏）：
- 通常应禁止直接访问一个对象中数据的实际表示，应通过操作接口来访问，这称为信息隐藏。
-
属性私有：get/set
private String name; private int age; private char sex; /*封装： 1.提高程序的安全性，保护数据 2，隐藏代码的实现细节 3.统一接口 4.系统的可维护性增加 */ //提供一些可以操作这个属性的方法 //提供一些publi的get，set方法 //get：获得这个数据，set：设置数据值 public String getName(){ return this.name; } public void setName(String name){ this.name = name; } public int getAge() { return age; } public void setAge(int age) {//安全性验证 if (age>120 || age<0){ this.age = 0; }else { this.age = age; } }Student s1 = new Student(); s1.setName("jyt"); System.out.println(s1.getName());
2.继承
-
继承的本质是对一批类的抽象，从而实现对现实世界更好的建模
-
extends的意思是“拓展”，子类是父类的拓展
-
java中只有单继承没有多继承
-
继承是类和类之间的一种关系，除此之外，类和类之间的关系还有依赖，组合，聚合等
-
继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends来表示
-
子类和父类的关系，从意义上讲应该具有“is a”的关系
-
object类
-
super
-
方法重写
//在java中所有类都默认继承Object类 //Person:人（父类） public class Person { private int money = 10_0000_0000; public void say(){ System.out.println("say something"); } public int getMoney() { return money; } public void setMoney(int money) { this.money = money; } //ctrl + h:查看继承关系树 }//super使用 public class Person { protected String name = "jiang"; public class Student extends Person { private String name = "jyt"; public void test(String name){ System.out.println(name);//蒋，传入test方法的name System.out.println(this.name);//jyt，当前方法（Student）的name System.out.println(super.name);//父类（Person）的属性name } } public class Application { public static void main(String[] args) { Student student = new Student(); student.test("蒋"); } }//父类无参构造 public Person() { System.out.println("Person的无参构造"); } //子类无参构造 public Student() { //隐藏代码，调用了父类的无参构造 super();//隐式调用了，只能写在子类构造器的第一行 System.out.println("Student的无参构造"); }
tips：
-
super：
- super调用父类的构造方法，必须在构造方法的第一个
- super只能出现在子类的构造方法或者方法中
- super和this不能同时调用构造方法（都必须写在第一行）
-
this：
- 和super代表不同的对象
- this：调用者本身这个对象
- super：代表父类对象的引用
- 前提：
- this没有继承关系也可以使用
- super只能在继承关系存在才能使用
- 构造方法：
- this：本类的构造方法
- super：父类的构造方法
- 和super代表不同的对象
-
静态方法：
public class B { //重写都是方法的重写，和属性无关 public static void test(){ System.out.println("B=>test"); } } public class A extends B{ public static void test(){ System.out.println("A=>test"); } } public class Application01 { public static void main(String[] args) { //静态方法 //方法调用只和左边有关 A a = new A(); a.test();//A=>test //父类的引用指向子类 B b = new A(); b.test();//B=>test } } -
非静态方法才可以重写：
public class B { //重写都是方法的重写，和属性无关 public void test(){ System.out.println("B=>test"); } } public class A extends B{ @Override public void test(){ System.out.println("A=>test"); } } public class Application01 { public static void main(String[] args) { //非静态方法：重写 A a = new A(); a.test();//A=>test //子类重写了父类的方法 B b = new A(); b.test();//A=>test } }
tips：（重写）
-
重写：需要有继承关系，子类重写父类的方法
1.参数名称必须相同
2.参数列表必须相同
3.修饰符：范围可以扩大不可以缩小
4.抛出的异常：只能更少不能更多 -
重写： 子类和父类的方法必须一致，方法体不同
-
为什么需要重写：父类的功能子类不一定需要或不一定满足。
3.多态
-
即同一方法可以根据发送对象的不同而采用多种不同的行为方式
-
一个对象的实际类型是确定的，但可以指向的引用类型有很多
-
多态存在的条件
- 有继承关系
- 子类重写父类的方法
- 父类引用指向子类
-
注意：多态是方法的多态，属性没有多态
-
instanceof：（类型转换）引用类型
public class Person { public void run(){ System.out.println("run"); } public void speak(){ System.out.println("say"); } } public class Student extends Person{ @Override public void run() { System.out.println("son"); } public void eat(){ System.out.println("eat"); } } public class Application { public static void main(String[] args) { //一个对象的实际类型是确定的（new出来的类型） //new Student：Student类型 //new Person：Person类型 //可指向的引用类型具有多样性，父类的引用指向子类 //对象可以调用的方法主要看左边，和右边没有关系 Student s1 = new Student();//Student能调用的方法都是自己的或者是继承自父类的 Person s2 = new Student();//Person父类型，可以指向子类但是不能调用子类独有的方法 Object s3 = new Student(); s1.run(); s1.speak(); s2.run();//子类重写了父类的方法，执行子类 s1.eat(); ((Student)s2).eat(); } } -
多态：
1.多态是方法的多态，属性没有多态
2.父类和子类，存在关系，类型转换异常（ClassCastException）
3，存在条件：继承关系，方法重写 -
不可实现多态：
1.static方法属于类不属于实例对象
2.final修饰的为常量
3.private私有方法//Object > Person,String >Student,Teacher //System.out.println(x instanceof y);若x的引用类型同y有父子关系则可以编译通过，若x的实际类型和y有父子关系则为true Object object = new Student(); 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 String);//false System.out.println(object instanceof Teacher);//false 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 String); System.out.println(person instanceof Teacher);//person实际指向类型为Student，无父子关系，false -
instanceof：
-
System.out.println(x instanceof y);
-
可编译：x的引用类型同y有线型父子关系
-
结果：x的实际类型和y有线型父子关系则为true，反之为false
//类型转换 高转低(向下转型）：强制转换，低转高（向上转型）：自动转换 Person student = new Student(); ((Student)student).eat();//向下自动转型（类型）对象 Person person = student;//向上转型自动转 //person.eat();//报错，子类丢失了自己本身的一些方法 /* 1.父类引用指向子类对象 2，把子类型转换为父类，向上自动转型 3.把父类转换为子类向下强制转换 4，方便方法的调用，减少重复的代码 */ -
static关键字
-
静态变量（类变量）和非静态变量（实例变量）
private static int age;//静态（类）变量：所有对象可调用，利于多线程 private double score;//实例（对象）变量 public static void main(String[] args) { Student s1 = new Student(); System.out.println(s1.score); System.out.println(s1.age); System.out.println(Student.age);//static随着类创建产生，可以直接使用类名调用 } -
静态方法和非静态方法
public static void teach(){//静态方法 System.out.println("teach"); } public void say(){//非静态方法 } public static void main(String[] args) { teach();//静态方法可以直接调用 new Teacher().say();//实例化一个对象才可以调用非静态方法 //静态方法中不可调用非静态方法：因为静态方法随着和类同时产生，非静态方法和对象同时产生，静态方法早于非静态产生 } -
加载顺序：静态(加载一次）---->匿名------>构造方法
//2. { System.out.println("匿名代码块"); } //1.只执行一次 static { System.out.println("静态代码块"); } //3. public Person() { System.out.println("构造方法"); } public static void main(String[] args) { Person p1 = new Person(); System.out.println("======================="); Person p2 = new Person(); } } 输出结果： 静态代码块 匿名代码块 构造方法 ======================= 匿名代码块 构造方法 -
拓展：静态导入包
//静态导入包 import static java.lang.Math.random; public class Test { public static void main(String[] args) { System.out.println(random());//不需要Math.了 } }
抽象类
-
abstract修饰符可以用来修饰方法也可以修饰类，如果修饰方法，该方法即为抽象方法，如果修饰类，该类即为抽象类
-
抽象类中可以没有抽象方法，但是含抽象方法的类一定是抽象类
-
抽象类不可以使用new关键字来实例化，它是让子类来继承的
-
抽象方法只有方法的声明，没有方法的实现，它是让子类来实现的
-
子类继承抽象类就必须实现抽象类中没有实现的抽象方法，除非该子类也声明为抽象类
//抽象类abstract(类：使用extends实现，只有单继承（局限性）） public abstract class Action { //是一个约束，希望有人帮我们实现 //abstract，抽象方法，只有方法名，没有具体实现 public abstract void doSomething(); //1.抽象类不能new出来(不能被实例化），只能靠子类去实现，是一个大的空框架 //2.抽象类里可以写普通方法，但是抽象方法必须写在抽象类里 }//抽象类的所有方法，继承了抽象类的子类都需要帮它实现（重写），除非该子类也是抽象类 public class A extends Action { @Override public void doSomething() { } }
接口
-
普通类：只有具体实现
-
抽象类：具体实现和规范（抽象方法）都有
-
接口：只有规范（抽象方法）
-
接口就是规范，定义的是一组规则
-
接口的本质是契约，制定好大家都去遵守
-
OO的精髓就是对对象的抽象，最能体现出抽象的就是接口，设计模式的研究就是如何合理的抽象
//interface:定义接口，接口都需要实现类 public interface UserService { //接口中都是常量，修饰符为public static final int age = 99; //接口中的方法都是抽象的public abstract类型 void add(); void delete(); void insert(); void query(); } public interface TimeService { void timer(); }//抽象类：extends //接口：implements //实现了接口的类必须重写接口里的方法 public class UserServiceImpl implements UserService,TimeService { @Override public void add() { } @Override public void delete() { } @Override public void insert() { } @Override public void query() { } @Override public void timer() { } } -
接口作用：
- 一种约束，一种框架
- 定义一些方法，让不同的人去实现
- public abstract ：修饰方法
- public static final ：修饰常量
- 接口不能被实例化，接口中没有构造方法
- implements可以实现多个接口
- 接口中的方法必须被重写
多种内部类
-
内部类就是在类的内部在定义一个类，例如：在A的内部定义了一个B类，那么B对A来说就称为内部类，A对B就是外部类
-
分类：
- 成员内部类、
- 静态内部类
- 局部内部类
- 匿名内部类
public class Outer { private int id = 10; public void outer(){ System.out.println("这是外部类的方法"); } public class Inner{ public void in(){ System.out.println("这是内部类的方法"); } //可以获取外部类的私有属性 public void getID(){ System.out.println(id); } } }public class Application { public static void main(String[] args) { Outer outer = new Outer(); //内部类通过它的外部类来实例化 Outer.Inner inner = outer.new Inner(); inner.in(); inner.getID(); } }public class Test01 { public static void main(String[] args) { Apple apple = new Apple();//一个名为apple的Apple类对象 //没有名字初始化类(匿名对象),不用把实例保存到变量当中去 new Apple().eat(); //实现了接口的类，也没有名字（匿名内部类） new UserService(){//UserService userService(类名） = new UserService() public void hello() { } }; } } class Apple{ public void eat(){ System.out.println("eat"); } } interface UserService{ void hello(); }public class Test { public void method(){ //局部内部类 class Inner{ public void in(){ } } } }
标签：Day08,java,对象,void,System,println,new,public,out 来源： https://www.cnblogs.com/workplace-blog/p/16173607.html
本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享； 2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关； 3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关； 4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除； 5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。