哪个网站可以卖自己做的模型/精准营销的典型案例

封装概念：在java中通过对象实现数据和指令存储操作，该现象就属于封装行为。

体现方式：

类、对象、属性、方法

1. 对象中属性赋值

方式：

                                1.对象直接赋值

语法： 对象名.属性=值;

2.通过方法赋值

实现方法：

定义一个无返回、有参数方法

//定义一个为属性赋值的方法public void setFiled(String c,String t,double p) {color=c;type=t;price=p;}

封装·：通过访问限定符对类，属性，方法，构造方法的可访问范围进行限定，对外提供必要的访问接口。

封装的优点：

(1).良好的封装能够减少耦合。
(2).类内部的结构可以自由修改。
(3).可以对成员变量进行更精确的控制。
(4).隐藏信息，实现细节。

package com.newer.oop;public class 封装 {
//	定义私有属性private String name;private int age;private char gender;public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}public char getGender() {return gender;}public void setGender(char gender) {this.gender = gender;}public static void main(String[] args) {封装 f=new 封装();f.setAge(18);f.setGender('男');f.setName("张三");System.out.println(f.getAge());System.out.println(f.getGender());System.out.println(f.getName());}}

代码运行结果为：

18
男
张三

继承：

子类继承父类的属性和方法。

子类可以重写从父类继承来的属性和方法

子类可以对父类的属性和方法进行扩展

继承的优点：

1 提高了代码的复用性

2 提高了代码的维护性

3 建立了类与类之间的关系，继承是多态的前提。

父类;

package com.newer.oop;public class Person {
//	定义整形变量int age;
//	定义一个方法public void a() {System.out.println("我是父类的一个方法");}}

子类：

package com.newer.oop;public class Student extends Person {public static void main(String[] args) {
//		创建Student对象Student stu=new Student();
//		调用父类的属性stu.age=15;
//		调用父类的方法stu.a();}}

代码运行后结果为：

我是父类的一个方法

子类重写父类的方法

package com.newer.oop;public class Student extends Person {//	重写父类的方法public void a() {System.out.println("我是子类重写的一个方法");}public static void main(String[] args) {
//		创建Student对象Student stu=new Student();
//		调用父类的属性stu.age=15;
//		调用父类的方法stu.a();}}

代码运行后结果为：

我是子类重写的一个方法

重写要注意的事项：

在子类定义一个和父类中同名同参数列表同返回值的方法，访问限定符不能小于父类（同名同参同返回值）

多态：

（1）多种状态，相同类型的对象，调用相同的方法，得到结果可能不一样

（2）静态多态：由于重载机制导致的多态

（3）动态多态：由于重写机制导致的多态

多态就是对同一个对象，在不同时刻表现出来的不同形态

动物类：

package com.newer.oop;
/** 动物类*/
public class Animal {
//	定义一个吃东西的方法public void eat() {System.out.println("吃东西");}}

狗类：

package com.newer.oop;
//狗类
public class Dog extends Animal {@Overridepublic void eat() {System.out.println("狗吃排骨");}
//	自己独有的方法public void yao() {System.out.println("狗咬人");}}

兔子类：

package com.newer;import com.newer.oop.Animal;//兔子类
public class Rubbit extends Animal {@Overridepublic void eat() {System.out.println("兔子吃胡萝卜");}
//	自己独有的方法public void yao() {System.out.println("兔子不咬人");}}

测试类：

package com.newer;import com.newer.oop.Animal;
import com.newer.oop.Dog;//测试类
public class Test {public static void main(String[] args) {//父类的引用指向子类的实例Animal a=new Dog();
//		创建狗类对象Dog d=new Dog();a.eat();
//		调用狗类里的方法d.yao();Animal a1=new Rubbit();
//		创建兔子对象Rubbit r=new Rubbit();a1.eat();r.yao();}}

代码运行结果：

狗吃排骨
狗咬人
兔子吃胡萝卜
兔子不咬人

 引用转型分类：

1. 向上转型

Person p=new Student();  父类引用指向子类的实例

     2.向下转型

Person per2=new Student();Student stu=(Student)per2;

super 限定符

如果需要在子类方法中调用父类被覆盖的实例方法. 
则可以使用 super 限定来调用父类被覆盖的实例方法.

package com.newer.oop;public class Person {
//	定义整形变量int age=15;
//	定义一个方法public void a() {System.out.println("我是父类的一个方法");}}package com.newer.oop;public class Student extends Person {//	重写父类的方法public void a() {System.out.println("我是子类重写的一个方法");}//	调用父类的属性的方法public void b() {System.out.println(super.age);}public static void main(String[] args) {
//		创建Student对象Student stu=new Student();
//		调用父类的属性stu.age=15;
//		调用父类属性的方法stu.b();}}