类对象

1. 线程基础 1.1 线程的创建方式 1.1.1 继承Thread类 public class MyThread extends Thread { @Override public void run() { //获取线程名称 // String name = getName(); // System.out.println(name); // Thread t = Thread.currentThread(); // String name = t.getName(); // System.out.println(name); System.out.println(Thread.currentThread().getName()); } Test类 public class Demo01GetThreadName { public static void main(String[] args) { MyThread mt = new MyThread(); mt.start(); new MyThread().start(); new MyThread().start(); } 1.1.2 实现Runnable接口 public class RunnableImpl implements Runnable { @Override public void run() { for

【推荐】2019 Java 开发者跳槽指南.pdf(吐血整理) >>> 原文链接： http://blog.leichunfeng.com/blog/2015/06/26/objective-c-associated-objects-implementation-principle/ 我们知道，在 Objective-C 中可以通过 Category 给一个现有的类添加属性，但是却不能添加实例变量，这似乎成为了 Objective-C 的一个明显短板。然而值得庆幸的是，我们可以通过 Associated Objects 来弥补这一不足。 在阅读本文的过程中，读者需要着重关注以下三个问题： 关联对象被存储在什么地方，是不是存放在被关联对象本身的内存中？ 关联对象的五种关联策略有什么区别，有什么坑？ 关联对象的生命周期是怎样的，什么时候被释放，什么时候被移除？ 与 Associated Objects 相关的函数主要有三个，我们可以在 runtime 源码的 runtime.h 文件中找到它们的声明： OBJC_EXPORT void objc_setAssociatedObject(id object, const void *key, id value, objc_AssociationPolicy policy) OBJC_EXPORT id objc

内部类：一个类的定义放在另一个类的定义内部。 内部类 普通内部类：普通内部类对象需要依赖外部类对象 静态内部类：静态内部类对象不需要依赖外部类对象 匿名内部类：主要是针对抽象类和接口，重写其方法。 局部内部类：声明在方法体内，不在方法体内无法使用其类。 普通内部类 TestOne.java public class TestOne { public int test = 1; private int test2 = 2; public TestOne() { InnerOne innerObj = new InnerOne(); //外部类对象也可以通过内部类的对象引用来访问内部类中定义的所有访问权限的字段 System.out.println("inner="+innerObj.inner); System.out.println("inner2="+innerObj.inner2); } public class InnerOne {//普通内部类：依赖内部类TestOne public int inner = 3; private int inner2 = 4; //内部类对象可以访问外部类对象中所有访问权限的字段. public InnerOne() { System.out.println("test="+test); System.out.println("test2=

视频教程 https://study.163.com/course/courseLearn.htm?courseId=1005985001#/learn/video?lessonId=1053351122&courseId=1005985001 #类对象的遍历 #方式一： class Person: def __init__(self): self.age = 0 def __getitem__(self, item): self.age=self.age+1 if self.age >= 10: raise StopIteration('停止遍历') #抛出异常 return self.age d=Person() for i in d:#d 每次执行__getitem__获取它的返回值,遇到异常结束遍历 print(i) print('还在执行吗') #类对象的遍历 #方式二： class Person: def __init__(self): self.age = 0 def __getitem__(self, item): print('__getitem__函数') self.age=self.age+1 if self.age >= 10: raise StopIteration('停止遍历') #抛出异常 return self.age def __iter__

内部类：一个类的定义放在另一个类的定义内部。 内部类 普通内部类：普通内部类对象需要依赖外部类对象 静态内部类：静态内部类对象不需要依赖外部类对象 匿名内部类：主要是针对抽象类和接口，重写其方法。 局部内部类：声明在方法体内，不在方法体内无法使用其类。 普通内部类 TestOne.java public class TestOne { public int test = 1; private int test2 = 2; public TestOne() { InnerOne innerObj = new InnerOne(); //外部类对象也可以通过内部类的对象引用来访问内部类中定义的所有访问权限的字段 System.out.println("inner="+innerObj.inner); System.out.println("inner2="+innerObj.inner2); } public class InnerOne {//普通内部类：依赖内部类TestOne public int inner = 3; private int inner2 = 4; //内部类对象可以访问外部类对象中所有访问权限的字段. public InnerOne() { System.out.println("test="+test); System.out.println("test2=

多态的概念： 　　简单来说就是事物在运行过程中存在的不同状态，即父类或接口定义的引用变量指向子类或具体实现类的实例对象。程序调用方法在运行期才进行动态绑定，而不是引用变量的类型中定义的方法。 多态存在的前提： 1、存在继承关系，子类继承父类； 2、子类重写父类的方法； 3、父类引用指向子类对象。 具体实例： 1、定义一个父类：Animal 1 package demo; 2 3 class Animal{ 4 int num = 10; 5 static int age = 20; 6 public void eat() { 7 System.out.println("动物吃饭"); 8 } 9 public static void sleep() { 10 System.out.println("动物睡觉"); 11 } 12 public void run() { 13 System.out.println("动物奔跑"); 14 } 15 } 2、子类：Cat继承Animal 1 package demo; 2 3 public class Cat extends Animal{ 4 int num=80; 5 static int age=90; 6 String name="TomCat"; 7 @Override 8 public void eat() { 9 //

　　首先，什么是多态？我们应该从什么角度来理解多态？其实，我们不妨把多态理解成一种事物的多种存在形态，比如，猫和狗都可以变成动物，而动物又可以变成猫和狗。 为了充分理解多态，我们可以从以下这几个方面来理解多态。 第一、从多态的体现方面：我们使用多态的时候，创建的是父类的引用，开辟的是子类的空间，由于没有开辟父类的空间，所以是父类的引用指向子类对象，并不是真正的父类自己创建了对象，而且父类对象的引用还可以作为函数参数来接收子类对象哦！ 第二、多态实现的前提：必须是类与类之间要有关系，要么继承，要么实现，存在覆盖，其实就是有抽象函数。 第三、从多态的好处：大大提高程序的可拓展性 第四、多态的应用：1.父类对象的引用指向子类对象，其实本质上是一个向上转型，就像int转成double一样，儿子穿了一身爸爸的衣服，扮成了爸爸。2.但变成了爸爸之后，只能使用爸爸特有的技能，儿子怎么能够使用自己本身的技能呢？这时候就需要向下转型，脱下伪装，将父类对象的引用强转成子类类型，就可以使用子类特有的技能了。 第五、多态的弊端：提高了拓展性，但是只能使用父类的引用访问父类的成员。 ------------------------------------------------------------------------------------------例子----------------------

这是java面对对象里的三大特性之一，今天我们讲的就是多态， 理解java的三大特性——多态对象是类的实例，而类是对象的抽象化： 　　面向对象编程有三大特性：封装、继承、多态。   封装：隐藏了类的内部实现机制，可以在不影响使用的情况下改变类的内部结构，同时也保护了数据。对外界而已它的内部细节是隐藏的，暴露给外界的只是它的访问方法。   继承：是为了重用父类代码。两个类若存在IS-A的关系就可以使用继承，子类是一个父类。   多态：就是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定，而是在程序运行期间才确定，即一个引用变量倒底会指向哪个类的实例对象，该引用变量发出的方法调用到底是哪个类中实现的方法，必须在由程序运行期间才能决定。因为在程序运行时才确定具体的类，这样，不用修改源程序代码，就可以让引用变量绑定到各种不同的类实现上，从而导致该引用调用的具体方法随之改变，即不修改程序代码就可以改变程序运行时所绑定的具体代码，让程序可以选择多个运行状态，这就是多态性。   比如你是一个酒神，对酒情有独钟。某日回家发现桌上有几个杯子里面都装了白酒，从外面看我们是不可能知道这是些什么酒，只有喝了之后才能够猜出来是何种酒。你一喝，这是剑南春、再喝这是五粮液、再喝这是酒鬼酒….在这里我们可以描述成如下： 酒 a = 剑南春 酒 b = 五粮液 酒 c = 酒鬼酒

第7章继承 理解继承的基础知识、调用超类构造函数、使用super访问超类成员、创建多级类层次结构、了解何时调用构造函数、理解子类对象的超类引用、重写方法、使用重写方法实现动态方法分配、使用抽象类、使用final、了解Object类 继承的基础知识 Java不支持一个子类继承多个超类。但是，可以创建类的继承层次结构，其中的一个子类可以称为另一个子类的超类。 构造函数与继承 什么样的构造函数负责创建子类对象呢？ 是超类构造函数还是子类构造函数？ 超类的构造函数构造超类部分，子类的构造函数构造对象的子类部分。 因为超类并不知道或无权访问子类的任何元素。 当子类和超类都定义构造函数时，这种情况下的两个构造函数都要执行。这种情况下可以使用另外一个关键字。super super的两种用法：第一种调用超类的构造函数，第二种用于访问被子类成员隐藏的超类成员。 使用super调用超类构造函数 super（）必须是在子类中执行的第一条语句。 class A1 { private int a ; A1 ( ) { a = 0 ; } A1 ( int aa ) { a = aa ; } public int getA1 ( ) { return a ; } public void setA1 ( int a1 ) { a = a1 ; } } class B1 extends A1 { private

Java编程思想学习笔记(10) 内部类 可以将一个类的定义放在另一个类的定义内部，这就是内部类。 创建内部类 例子： public class Outer { class Inner_1{ private int i = 1; public int value(){ return i; } } class Inner_2{ private String string; Inner_2(String s){ string = s; } String getString(){ return string; } } public void get(String s){ Inner_1 inner_1 = new Inner_1(); Inner_2 inner_2 = new Inner_2(s); System.out.println(inner_2.getString()); } public static void main(String[] args) { Outer outer = new Outer(); outer.get("Hello"); } } 创建内部类的方式很简单，就是把类的定义放置于外围类的里面。 当我们在get方法中使用内部类的时候，与使用普通类没什么区别。 更加典型的方法，外部类有一个方法，该方法返回一个指向内部类的引用。 public class