《传智 面向对象到线程.docx》由会员分享，可在线阅读，更多相关《传智 面向对象到线程.docx（54页珍藏版）》请在taowenge.com淘文阁网|工程机械CAD图纸|机械工程制图|CAD装配图下载|SolidWorks_CaTia_CAD_UG_PROE_设计图分享下载上搜索。
1、1.构造方法，类成员实例成员，匿名对象：定义一个类class 类名1n 构造方法（构造器，构造子）默认无参的 可以给字段赋初值。通过改变构造器的参数列表来对构造器进行重载0n个字段0nstatic 关键词：1.随着类的加载而加载2.优先于对象存在3.被所有对象所共享4.可以直接被类名调用注意：静态方法只能访问静态成员！但是非静态成员可以访问静态成员静态方法中不可以使用 this，super 关键词主方法 main 是静态的方法的调用：1.对象调用：对象.方法 （实参）static 修饰的方法对象也可以调用其实自动转换类名调用。2.类调用：这个方法所在类的名字 前提这个方法是 static 所修
2、饰的总结：我们把没有用 static 修饰的方法或字段，属于对象 -实例成员使用static 修饰的方法或字段叫 -类成员调用：若是实例成员只能通过对象类调用。若是类成员两个都可以。在jvm内存区中有一块存储区域：叫静态区域切记通过对象对静态数据修改时，引起所有的对象数据变化。匿名对象：new person（）;没有名字，且只能用一次。应用：引用数组类型数组分析成员变量，局部变量（防止就近原则）例子： package day1;public class GaoZaoqi public static void main (String args)CellPhone.brand = htc;Cel
3、lPhone c = new CellPhone();c.show();CellPhone c1 = new CellPhone(htc,red,1000);c1.show();/匿名对象System.out.println(p1 = p1 +(c1 = c1);System.out.println(new CellPhone = new CellPhone +(new CellPhone() = new CellPhone();/引用类型数组的分析Student s1 = new Student(xiao);Student s2 = new Student(hehe);s1.showinfo
4、();s2.showinfo();Student sarr = new Student s1,s2 ;for (Student s : sarr )s.fees();s1.showinfo();s2.showinfo();class CellPhone CellPhone()CellPhone(String brand ,String color)CellPhone(String brand ,String color,double price)this.color = color;this.price = price;static String brand;String color;doub
5、le price;void show ()/ 变量的就近原则String color = black; System.out.println(牌子+brand+颜色+color+价格+price);class StudentStudent()Student( String name )this.name = name ;String name ;boolean unfees = false ;void showinfo ()System.out.println(name +学费+unfees);void fees()unfees = true;结果：牌子htc颜色black价格0.0牌子htc
6、颜色black价格1000.0p1 = p1 truenew CellPhone = new CellPhone falsexiao学费falsehehe学费falsexiao学费truehehe学费true面向对象：封装，继承，多态。封装：1.把对象的状态和行为看成一个统一的整体，将二者存放在一个独立的模块中（类）2.信息影藏，把不需要让外界知道的信息隐藏起来尽可能隐藏对象功能实现细节和字段封装机制在程序中的体现：把描述的对象的状态用字段表示，描述对象的行为用方法表示，把字段和方法定义在一个类中并保证外界不能随意更改其内部的字段，和调用其内部的功能。程序中的体现：将类中的成员变量私有化（pr
7、ivate）外界通过（get/set）方法可对变量进行访问boolean 类型的变量没有get 只有is get/set Oooo (Oooo 这个才是属性，不是方法中的字段，但是一般情况下属性名和字段名是一样的)this：表示当前对象，谁调用方法谁就是当前的对象。1.this指向对象他自己，表示代表该方法的对象的引用2.当必须指出当前使用方法的对象是谁时要使用this3.有时候使用this可以处理方法中成员变量和参数重名的情况。4.this可以看作一个变量，他的值是当前对象的引用。当构造器调用本身的构造器可以用this（）必须首行当你判断不了一个变量是指谁的时候执行就近原则 继承和覆写：所有
8、类默认的父类是Object若子类的直接父类不是Object 则Object是他的间接父类泛化：把子类里的共性抽取到父类里的过程。特化：子类在父类的基础之上子类定义了自己特有的行为特征过程。原则：父类放共性，子类放个性。继承是一种从一般到特殊的关系。提高了代码的复用率。让类与类之间产生关系，多态的前提。子类与父类：父类的私有成员子类不能继承到。Java只支持单继承，不支持多继承。一个子类只有一个直接父类。在继承操作中，对于子类对象的实例化：子类对象在实例化之前必须首先调用父类中的构造方法之后在调用自身的构造方法子类不能直接访问父类的私有成员：但是子类可以调用父类中的非私有方法间接的访问父类的私有
9、成员。覆写（重写）：子类扩展父类（子类是父类的一种特殊情况）主要是以父类为基础，然后添加属于自己的字段和方法。子类需要覆写父类的方法。当父类的某个方法不适合于子类本身的特征行为时就当覆写父类中应当改变的方法。遵循的原则：一同两小一大。（一同）方法的签名必须相同。（两小）子类方法的返回值类型比父类方法的返回值类型更小或者相等。子类方法申明抛出的异常应比父类方法申明抛出的异常更小或者相等。（一大）子类方法的访问呢权限应比父类方法的更大或相等。 Overload Override 比较判断规则 两同一不同 一同两小一大权限 没有权限要求 被覆写的方法不能拥有比父类更严格的权限范围 一个类中 子类中多
10、态 编译时多态 运行时多态super：指父类对象，super()位于子类构造器的首行例子：package chuanzhi;public class JiChengFuXie public static void main (String args)Student1 s = new Student1();class People People(String name)this.name = name;System.out.println(People);private String name;String age;int id;protected Object skin()System.out
11、.println(我是一个白人);return null;class BlackMan extends People BlackMan()super( );/方法的覆写 override 一同两小一大Overridepublic String skin()System.out.println();/调用父类的方法super.skin();return null;class Student1 extends People Student1()super(小黑);System.out.println(Student1);int sNum;结果：PeopleStudent1多态：Polymorphi
12、sm1.编译时的类型由声明该变量时使用的类型决定，运行时的类型由实际赋给变量的对象决定。2.如果编译时类型和运行时类型不同，就会出现多态（例如 String s = new String（）；等号左边的叫编译类型：右边的叫运行类型）前提：继承Person p = new People（）；Student s = new Student（）；People p = new Student（）；把运行类型当做 对象的实际类型 也就是对象的真正类型。把编译类型当做，把对象看成什么类型例如 ：p是一个学生 ，而学生是一个人。前提 ：Student extends People 。引用关系：父类变量指向子
13、类对象多态：指同一个实体同时具有多种形式。例如：吃面，但是面的种类有好多种，这里的面就是多种形态的。实现多态的机制：父类的引用变量可以指向子类的实例对象，而程序调用的方法在运行期间才动态绑定就是引用变量所指向的真正实例对象的方法，也就是内存里真正运行的哪个对象的方法，而不是引用变量的类型中定义的的方法。多态的作用：1.把不同的子类对象都当做父类类型来看，可以屏蔽子类对象的差异。2.写出通用的代码，做出通用的编程，以适应需求的不断变化。只修改方法的实现，不修改方法的声明。分类：编译时多态：方法的重载运行时多态：方法的重写强调：静态方法不能被覆写，仅仅表示和父类一个样的方法而已，因为方法的覆写和对
14、象有关，而静态的和对象无关。类型转换：向上转型：小-大 例如（Dog d = new ZangAo（） ）向下转型：大-小 例如（ZangAo z = （ZangAo）d ）一般我们在进行强转换之前都会先判断是不是同一个类型的。对象 instanceof 类 结果是 boolean 类型注意 ：instanceof 不能随便用若对象A的类型和B之间没有关系，就不能使用 instanceof 运算符。多态时的方法调用：在多态情况下：1.此时该父类的变量不能再访问子类中自己特有的字段和方法；2.若子类覆写了父类的方法，那么此时通过父类的变量访问到的方法，实际上是子类的方法。动态绑定是指在执行期间（
15、而非编译期）判断所引用对象的实际类型，更具其实际类型调用其方法。多态大例子：package chuanzhi;public class DuoTai public static void main(String args)Dog1 h = new Ha();Dog1 z = new Zang();Dog1 g = new Dog1();Zoo o = new Zoo();o.feed(z);o.feed(h);h.eat(); /当eat 方法被子类覆写了以后，父类的引用变量调用的则是实际对象的eat 方法/h.show(); 父类的引用变量不能指向 子类的方法。if (h instanceo
16、f Ha) / 判断 h的实际类型是不是Ha 没有关系的类不要用instanceof比较Ha a = (Ha)h;a.show();System.out.println(-);/ 养一群狗o.feed(z,h,g); /g只是一个狗类而已class Dog1 void eat ()System.out.println(抽象狗吃狗食);class Ha extends Dog1 void eat ()System.out.println(哈士奇爱吃的);void show ()System.out.println(雪地狗);class Zang extends Dog1 void eat ()S
17、ystem.out.println(藏獒喜欢吃肉);void show ()System.out.println(草原狗);class Zoo void feed (Dog1. g) / 相当于创建了一个 Dog1 类型的 g数组for (Dog1 d : g) /for 循环的简单用法 d.eat();if(d instanceof Ha)Ha a = (Ha)d;a.show();else if (d instanceof Zang )Zang z = (Zang)d;z.show(); elseSystem.out.println(这个是狗吗);结果：藏獒喜欢吃肉草原狗哈士奇爱吃的雪地狗
18、哈士奇爱吃的雪地狗-藏獒喜欢吃肉草原狗哈士奇爱吃的雪地狗抽象狗吃狗食这个是狗吗组合关系：继承：拓展，是一种从一般到特殊的关系，子类对象是父类的一种。组合：一个类里面包含另一个类的引用，这种关系我们称为包含关系。例子 见Test.ZuHe.java 包装类：基本数据类型：基本数据类型包装类byteByteshortShortintIntegerlongLongcharCharacterfloatFloatdoubleDoublebooleanBoolean基本数据类型和其包装类作为成员变量时的初始值的差异：int 0Integer null八大基本数据类型的包装类的构造方法基本就两类例如：Int
19、eger：详细见api文档Integer（int value）基本数据类型Integer（String s）String类型char 不同 char 没有String 应为char只有一个字符，所以只有一个构造方法包装类比基本数据类型强大体现在，对象的功能和状态。比如有类型转换什么的包装类-基本类型调用 xxxValue（）；基本类型-其包装类new 包装类（基本数据类型值）；String -基本数据类型static xxx parseXxx（String s）String和基本数据类型之间的转换String -基本数据类型static xxx parseXxx（String s）基本数据类型
20、-String String s = i +; 也可以（不存在转关系，是组成一个新的字符串）static toString(int xxx)扩展：基本数据类型-StringString类 .public static String valueof（int i）重点int 和Integer 是不同的数据类型：所以：可以共存例子：public static void show（int i）public static void show （Integer i）.main()但是：Int i1 = 1;Integer i2 = 2;show (i1);show (i2);/如果 public stat
21、ic void show（Integer i） 不存在也可以调用 show（int i）装箱和拆箱：装箱：基本数据类型-包装类类型拆箱：包装类类型 -基本数据类型java5 开始提供了自动装箱和拆箱。自动装箱：Integer age = 17;自动拆箱：int age1 = age;例子：int i1 = 12;int i2 = 12;System.out.println(i1=i2);/trueInteger in1 = new Integer(12);Integer in2 = new Integer(12);System.out.println(in1=in2);/false /这里比较
22、的是地址in1 = 12;in2 = 12;System.out.println(in1=in2);/true /这里才用到了享元模式。in1 = -12;in2 = -12;System.out.println(in1=in2);/truein1 = -250;in2 = -250;System.out.println(in1=in2);/false这是为什么？ 涉及到一个享元模式。原先是一个区间的是经常使用 被缓存了 实际上是用的同一个东西所以为true 。最小 -128到 127 就是一个byte的区间 具体在 Integer 类中一个叫 IntegerCache的内部类总结：new 出
23、来的比较地址，肯定不想等赋上去的也是比较地址，但是在一定区间类相等简单的例子：public static void main(String args)Integer i = new Integer(17);Integer j = new Integer(18);System.out.println(i+ +j);System.out.println(Integer.MAX_VALUE+n+Integer.MIN_VALUE);/ 十进制转换成二进制 八进制等，包装类的好处。System.out.println(Integer.toBinaryString(5);/但是 byteValue（）（
24、包装数据类型转成基本数据类型） 不需要传参数是应为 它是对象调用的，而对象里有值。/Boolean b = new Boolean(true);Boolean b = new Boolean(trues);/只有当 里的值为 true 时 才是true （不分大小写），否则都是false 。System.out.println(b=+b);b = Boolean.FALSE; / 等于 FALSE = new Boolean (false)Object类：类Object 是类的层次结构根类，每个类都使用 Object 作为超类，所有对象（包括数组）都实现这个类的方法。一切数据类型都可以用Obj
25、ect接收常见方法：boolean equals （Object obj）比较两个对象是不是相等。int hashCode（） 返回该对象的哈希码值。String toString（） 返回该对象的字符串表示。equals ：区别与 = 在于它的子类Override默认的是比较默认的地址，有的时候我们不需要比较地址，只关心值。也就是父类的方法不适合子类，就要求子类覆写该方法，比如Integer类例子：System.out.println(new Integer(12).equals(new Integer(12);/true/equals System.out.println(new Obje
26、ct().equals(new Object();/falseSystem.out.println(new String().equals(new String();/true 说明 在子类String中equals 进行了重写System.out.println(new String() = new String();/false只是比较地址为什么呢？见原代码Integer.javapublic boolean equals(Object obj)if(obj instanceof Integer) return this.value = (Integer)obj).intValue;ret
27、urn false;hashCode：/hashCode/这两个hashCode值不一样System.out.println(new Object().hashCode();System.out.println(new Object().hashCode();Object o = new Object();/ 这两个hashCode 值一样System.out.println(o.hashCode();System.out.println(o.hashCode();String toString：描述对象，把对象转换成String返回该对象的字符串表示，以字符串的形式描述对象状态。源代码：pu
28、blic String toString（）return getClass().getName()+ Integer.toHexString(hashCode();/String toString/打印一个对象，其实就是打印对象的toString方法ObjectDemo od =new ObjectDemo();System.out.println(od); System.out.println(od.toString();/结果都是chuanzhi.ObjectDemo6d06d69c /即全限定名+十六进制hashCode/chuanzhi是包名,ObjectDemo是包下的类,6d06d
29、69c其实就是对象的16进制hashCode/证明Integer hashcode = od.hashCode();System.out.println(Integer.toHexString(hashcode);/结果6d06d69c /一般情况下建议每个类都覆写toString 方法例子：public class ToStringDemo private String name;private String genter;private Integer age;ToStringDemo(String name,String genter,Integer age)this.age = age
30、;this.genter = genter;this.name = name;public static void main(String args)System.out.println( new ToStringDemo(小明,男,13);/重写toString 方法public String toString()return name+this.name+ ,genter+this.genter+ ,age+this.age;代码块：普通代码块：方法中花括号就是普通代码块。构造代码块：1.定义在类里面，方法外面。2.每次实例化的时候执行。3.比构造方法先执行。静态代码块：1.在构造代码块之
31、前加static关键字（直接在花括号前面加static）。2.静态代码块比main方法还要提前运行。3.不管创建多少对象，只执行一次。4.可以给静态变量赋初值。同步代码块：后面才学。构造方法私有化：1.避免外界创建某类的实例，反射技术可以让外界创建实例。2.只能在本类中实例化。单例模式：保证整个项目运作期间某个对象有且只有一个。1.饿汉式：把构造方法私有化，不允许外界再创建对象。创立一个静态的实例（类中，方法体外）相当于一个类的静态变量。向外提供一个全局的公共的访问该对象的方法。2.懒汉式：线程不安全。例子：public class SingleDemo /* * 构造代码块，创建一次执行一次
32、 * */System.out.println(构造代码块);/* * 静态代码块，不管多少对象，只执行一次*/static System.out.println(静态代码块);SingleDemo()System.out.println(构造方法);public static void main(String args)/ 代码块System.out.println(main);new SingleDemo();new SingleDemo();System.out.println(main end);/* * 结果: *静态代码块 *main *构造代码块 *构造方法 *构造代码块 *构造
33、方法 *main end*/单例模式SingleDemo1 s1 = SingleDemo1.getS();SingleDemo1 s2 = SingleDemo1.getS();System.out.println(s1=s2);/* * 结果： *饿汉式 *true */SingleDemo2 s3 = SingleDemo2.getS();SingleDemo2 s4 = SingleDemo2.getS();System.out.println(s3=s4);/* * 结果： *懒汉式 *true */class SingleDemo1 /饿汉式/私有化构造方法private Sing
34、leDemo1()System.out.println(饿汉式);public static SingleDemo1 getS() return s;/实例化private static SingleDemo1 s = new SingleDemo1();class SingleDemo2 /懒汉式，线程不安全private SingleDemo2()System.out.println(懒汉式);public static SingleDemo2 getS() /判断s是不是为空if( s =null)/给s赋初值s = new SingleDemo2();return s;/实例化,没有给
35、值。private static SingleDemo2 s;final关键字：（修饰符没有先后关系，public final ，final public，都行）1.可以修饰类，方法，变量2.修饰的类不可以被继承，但是可以继承其他的类。（8大基本数据类型）3.修饰的方法不可以被覆写，但可以覆写父类的方法。4.修饰的变量称为常量，这些变量只能赋值一次（规范化，常量的名要全部大写，若多个单词组成，单词与单词用下划线连接）。 final修饰局部变量时既可以在定义时候指定默认值，也可以不指定，在后面指定，但只能一次。 对于final修饰的成员变量（全局变量）而言，一旦有了初始值之后，就不能被重新赋值，因此不可以在普通方法中对成员变量赋值。 要么在定义的时候赋值，要么在方法块和构造器中赋值。5.内部类在局部时，只可以访问被final修饰的局部变量。6.final修饰的引用类型变量，表示该变量的引用不能变（对象的地址），而不是该变量的值不能变（地址中的值）。（补充常量是值不变 ，变量是指值可变。）例子：public class InterfaceDemo static final Integer IN1;final Integer IN2;final Integer IN3 = 12;/通过构造代码段给成员变量赋初值IN2 =12;/