标签：全面 lis 方法 href 模板 random 耦合 哪些 成员方法
面向对象的程序由对象组成，每个对象包含对用户公开的特定功能部分和隐藏的实现部分
规模较小的问题分解为过程的开发方式较理想，面向对象更适用于解决规模较大的问题
类是构造对象的模板或蓝图
由类构造对象的过程称为创建类的实例
Java编写的所有代码都位于某个类的内部
封装
- 从形式上看，封装是将数据和行为组合在一个包中，并对对象的使用者隐藏了数据的使用方式
- 对象的数据称为实例域，操纵数据的过程称为方法
- 实现封装的关键在于绝对不能让类中的方法直接地访问其他类的实例域，程序仅通过对象的方法与对象数据进行交互
- 一个类可以全面地改变存储数据的方式，只要仍使用同样的方法操作数据，其他对象就不会知道或介意所发生的变化
继承
- 通过扩展一个类来建立另外一个类的过程称为继承
- 扩展后的新类具有所扩展类的全部属性和方法
对象的三个主要特性
每个对象都保存着描述当前特征的信息，即对象的状态
对象状态的改变必须通过调用方法实现，否则只能说明封装性遭到了破坏
类之间最常见的关系有依赖，聚合，继承
1、依赖
"use-a"关系，是一种明显的、最常见的关系
如果一个类的方法操纵另一个类的对象，就说一个类依赖于另一个类
应尽可能地将相互依赖的类减至最少，让类之间的耦合度最小
2、聚合
也称“关联”
"has-a"关系
类A的对象包含类B的对象
3、继承
"is-a"关系，表示特殊与一般的关系
1、初始化
函数内的局部变量，编译器不会直接给默认值，需要初始化后才能使用。但类的成员变量，编译器会给默认值，可以直接使用
new出对象后，内部属性值默认初始化为：
2、赋值
基本变量赋值是值拷贝
对象赋值是直接赋指针，两个对象指向内存中同一个地方
package OO;
/**
* Java类与对象
* @version 15:40 2019-09-28
* @author xxwang1018
*/
class Father {
private int money = 100; //私有
long mobile = 13999999999L;
public void hello() {
System.out.println("hello");
}
}
class Son extends Father {
public void hi() {
//子类可以扩展自己的成员方法
System.out.println("hi~~~~~");
}
public void s1() {
Son s = new Son();
System.out.println(s.mobile); //Son没有定义mobile, 而是通过父类继承的
//System.out.println(s.money); //error 父类的money是私有的，子类无法直接访问
//子类必须通过父类的方法才能访问父类的私有变量
s.hello(); //Son没有定义f1, 而是通过父类继承的
s.hi(); //Son可以自定义自己的成员方法
}
}
public class Class_Object {
private int a;
public void setA(int a) {
this.a = a;
}
public int add(int b) {
return this.a + b;
}
public static void main(String[] a) {
int b = 5;
Class_Object obj = new Class_Object();
obj.setA(10);
System.out.println(obj.add(b));
Son son=new Son();
son.s1();
}
}作用：对象产生时给成员变量赋值
一个类可以有多个构造函数，只要形参列表不相同即可
Java具有内存自动回收机制的，当变量退出其生命周期后，JVM会自动回收所分配的对象的内存
1、默认域初始化
如果构造器中没有显式地给域赋初值（有构造器），就会自动赋默认值：数值为0，布尔值为 false，对象引用为 null
2、有关参数的构造器
如果没有显式定义构造函数，Java编译器自动为该类产生一个空的无形参构造函数，将所有实例域设置为默认值
如果已经有显式的有参构造函数，则编译器无操作
如果类中提供了至少一个构造器，但是没有提供无参数的构造器，则构造对象时如果没有提供参数就会被视为不合法，为预防此事一般手动编写一个无参数构造器，例如
new Employee(){
//no information
}3、调用另一个构造器
如果构造器的第一个语句形如 this(…)，这个构造器将调用同一个类的另一个构造器(具体调用哪个要看参数配对)
调用构造器的步骤
- 所有数据域被初始化为默认值
- 按照在类声明中出现的次序，依次执行所有域初始化语句和初始化块
- 如果处理器第一行调用了第二个构造器，则执行第二个构造器主体
- 执行构造器主体
import java.util.*;
/**
* 对象构造
* @version 08:09 2019-09-30
* @auther xxwang1018
*/
public class ConstructorTest{
public static void main(String[] args){
Employee[] staff = new Employee[3];
staff[0] = new Employee("harry", 40000);
staff[0] = new Employee(60000);
staff[0] = new Employee();
//print out information about all Employee objects
for(Employee e : staff)
System.out.println("name="+ e.getName()+ ",id="+ e.getId()+ ",salary="+ e.detSalary());
}
}
class Employee{
private static int nextId;
private int id;
private String name = ""; //intance field initialization
private double salary;
//static initialization block
static{
Random generator = new Random;
//set nextId to a random number between 0 and 9999
nextId = generator.nextInt(10000);
}
//object initialization block
{
id = nextId;
nextId++;
}
//three overloaded constructors
public Employee(String aName, double aSalary){
name = aName;
salary = aSalary;
}
public Employee(double aSalary){
//calls the Employee(String, double) constructor
this("Employee #"+ nextId, aSalary);
}
//the default constructor
public Employee(){
//name initialized to "" --see above
//salary not explicitly set --initialized to 0
//id initialized in initialization block
}
public String getName(){
return name;
}
public double detSalary(){
return salary;
}
public int getId(){
return id;
}
}面向对象有一个法则：信息隐藏
打个比方：朋友再熟悉，也不会到他抽屉直接拿东西，而是通过他的公开接口来访问、修改东西
this作用
this.add(5,3); //调用本类的add方法, this可忽略this(5); //调用本类的只有一个形参的构造函数public class ThisTest {
private int id;
public ThisTest(int id) {
this.id = id; //指向本类中的成员变量
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
}标签：全面 lis 方法 href 模板 random 耦合 哪些 成员方法
原文地址：https://www.cnblogs.com/xxwang1018/p/11610853.html
